| package org.eclipse.efm.sew.xtext.ide.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.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; |
| import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA; |
| import org.eclipse.efm.sew.xtext.services.SEWGrammarAccess; |
| |
| |
| |
| import org.antlr.runtime.*; |
| import java.util.Stack; |
| import java.util.List; |
| import java.util.ArrayList; |
| import java.util.Map; |
| import java.util.HashMap; |
| /***************************************************************************** |
| * Copyright (c) 2018 CEA LIST. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v20.html |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| * |
| ****************************************************************************** |
| * Generated by Xtext 2.25.0 |
| *****************************************************************************/ |
| @SuppressWarnings("all") |
| public class InternalSEWParser extends AbstractInternalContentAssistParser { |
| public static final String[] tokenNames = new String[] { |
| "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_CHARACTER", "RULE_STRING", "RULE_XIDENDIFIER", "RULE_AT_IDENTIFIER", "RULE_INT", "RULE_ID", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'workflow'", "'symbex-workflow'", "'@sew'", "'@favm'", "'sew'", "'::'", "'.'", "':='", "'+:='", "'||'", "'or'", "'&&'", "'and'", "'=='", "'!='", "'==='", "'=!='", "'=/='", "'<'", "'<='", "'>'", "'>='", "'!'", "'not'", "'$env'", "'env'", "'true'", "'false'", "'form'", "'endform'", "'prototype'", "'endprototype'", "'section'", "'endsection'", "'|;|'", "'|i|'", "'{'", "'}'", "'>:'", "','", "'version:'", "'['", "']'", "':'", "'='", "';'", "'+'", "'*'", "'**'", "'/'", "'%'", "'('", "')'", "'&'", "'null'", "'-'", "'as'", "'is'", "'${'", "'?'", "'$time'", "'$delta'", "'$this'", "'$self'", "'$parent'", "'$super'", "'$system'" |
| }; |
| public static final int T__50=50; |
| public static final int RULE_CHARACTER=4; |
| 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__56=56; |
| 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_XIDENDIFIER=6; |
| public static final int RULE_ID=9; |
| 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=8; |
| 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=10; |
| 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 T__72=72; |
| public static final int RULE_STRING=5; |
| public static final int RULE_SL_COMMENT=11; |
| 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__77=77; |
| public static final int T__34=34; |
| public static final int T__78=78; |
| public static final int T__35=35; |
| public static final int T__79=79; |
| public static final int T__36=36; |
| public static final int T__73=73; |
| public static final int EOF=-1; |
| public static final int T__30=30; |
| public static final int T__74=74; |
| public static final int T__31=31; |
| public static final int T__75=75; |
| public static final int T__32=32; |
| public static final int T__76=76; |
| public static final int T__80=80; |
| public static final int RULE_WS=12; |
| public static final int RULE_ANY_OTHER=13; |
| public static final int RULE_AT_IDENTIFIER=7; |
| 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 InternalSEWParser(TokenStream input) { |
| this(input, new RecognizerSharedState()); |
| } |
| public InternalSEWParser(TokenStream input, RecognizerSharedState state) { |
| super(input, state); |
| |
| } |
| |
| |
| public String[] getTokenNames() { return InternalSEWParser.tokenNames; } |
| public String getGrammarFileName() { return "InternalSEW.g"; } |
| |
| |
| private SEWGrammarAccess grammarAccess; |
| |
| public void setGrammarAccess(SEWGrammarAccess grammarAccess) { |
| this.grammarAccess = grammarAccess; |
| } |
| |
| @Override |
| protected Grammar getGrammar() { |
| return grammarAccess.getGrammar(); |
| } |
| |
| @Override |
| protected String getValueForTokenName(String tokenName) { |
| return tokenName; |
| } |
| |
| |
| |
| // $ANTLR start "entryRuleWorkflow" |
| // InternalSEW.g:66:1: entryRuleWorkflow : ruleWorkflow EOF ; |
| public final void entryRuleWorkflow() throws RecognitionException { |
| try { |
| // InternalSEW.g:67:1: ( ruleWorkflow EOF ) |
| // InternalSEW.g:68:1: ruleWorkflow EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleWorkflow(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleWorkflow" |
| |
| |
| // $ANTLR start "ruleWorkflow" |
| // InternalSEW.g:75:1: ruleWorkflow : ( ( rule__Workflow__Group__0 ) ) ; |
| public final void ruleWorkflow() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:79:2: ( ( ( rule__Workflow__Group__0 ) ) ) |
| // InternalSEW.g:80:2: ( ( rule__Workflow__Group__0 ) ) |
| { |
| // InternalSEW.g:80:2: ( ( rule__Workflow__Group__0 ) ) |
| // InternalSEW.g:81:3: ( rule__Workflow__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getGroup()); |
| } |
| // InternalSEW.g:82:3: ( rule__Workflow__Group__0 ) |
| // InternalSEW.g:82:4: rule__Workflow__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleWorkflow" |
| |
| |
| // $ANTLR start "entryRuleProlog" |
| // InternalSEW.g:91:1: entryRuleProlog : ruleProlog EOF ; |
| public final void entryRuleProlog() throws RecognitionException { |
| try { |
| // InternalSEW.g:92:1: ( ruleProlog EOF ) |
| // InternalSEW.g:93:1: ruleProlog EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleProlog(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleProlog" |
| |
| |
| // $ANTLR start "ruleProlog" |
| // InternalSEW.g:100:1: ruleProlog : ( ( rule__Prolog__Group__0 ) ) ; |
| public final void ruleProlog() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:104:2: ( ( ( rule__Prolog__Group__0 ) ) ) |
| // InternalSEW.g:105:2: ( ( rule__Prolog__Group__0 ) ) |
| { |
| // InternalSEW.g:105:2: ( ( rule__Prolog__Group__0 ) ) |
| // InternalSEW.g:106:3: ( rule__Prolog__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getGroup()); |
| } |
| // InternalSEW.g:107:3: ( rule__Prolog__Group__0 ) |
| // InternalSEW.g:107:4: rule__Prolog__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleProlog" |
| |
| |
| // $ANTLR start "entryRuleReservedWord" |
| // InternalSEW.g:116:1: entryRuleReservedWord : ruleReservedWord EOF ; |
| public final void entryRuleReservedWord() throws RecognitionException { |
| try { |
| // InternalSEW.g:117:1: ( ruleReservedWord EOF ) |
| // InternalSEW.g:118:1: ruleReservedWord EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getReservedWordRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleReservedWord(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getReservedWordRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleReservedWord" |
| |
| |
| // $ANTLR start "ruleReservedWord" |
| // InternalSEW.g:125:1: ruleReservedWord : ( ( rule__ReservedWord__Alternatives ) ) ; |
| public final void ruleReservedWord() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:129:2: ( ( ( rule__ReservedWord__Alternatives ) ) ) |
| // InternalSEW.g:130:2: ( ( rule__ReservedWord__Alternatives ) ) |
| { |
| // InternalSEW.g:130:2: ( ( rule__ReservedWord__Alternatives ) ) |
| // InternalSEW.g:131:3: ( rule__ReservedWord__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getReservedWordAccess().getAlternatives()); |
| } |
| // InternalSEW.g:132:3: ( rule__ReservedWord__Alternatives ) |
| // InternalSEW.g:132:4: rule__ReservedWord__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ReservedWord__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getReservedWordAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleReservedWord" |
| |
| |
| // $ANTLR start "entryRuleXID" |
| // InternalSEW.g:141:1: entryRuleXID : ruleXID EOF ; |
| public final void entryRuleXID() throws RecognitionException { |
| try { |
| // InternalSEW.g:142:1: ( ruleXID EOF ) |
| // InternalSEW.g:143:1: ruleXID EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXIDRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleXID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXIDRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleXID" |
| |
| |
| // $ANTLR start "ruleXID" |
| // InternalSEW.g:150:1: ruleXID : ( ( rule__XID__Alternatives ) ) ; |
| public final void ruleXID() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:154:2: ( ( ( rule__XID__Alternatives ) ) ) |
| // InternalSEW.g:155:2: ( ( rule__XID__Alternatives ) ) |
| { |
| // InternalSEW.g:155:2: ( ( rule__XID__Alternatives ) ) |
| // InternalSEW.g:156:3: ( rule__XID__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXIDAccess().getAlternatives()); |
| } |
| // InternalSEW.g:157:3: ( rule__XID__Alternatives ) |
| // InternalSEW.g:157:4: rule__XID__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__XID__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXIDAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleXID" |
| |
| |
| // $ANTLR start "entryRuleUFI" |
| // InternalSEW.g:166:1: entryRuleUFI : ruleUFI EOF ; |
| public final void entryRuleUFI() throws RecognitionException { |
| try { |
| // InternalSEW.g:167:1: ( ruleUFI EOF ) |
| // InternalSEW.g:168:1: ruleUFI EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUFIRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUFIRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleUFI" |
| |
| |
| // $ANTLR start "ruleUFI" |
| // InternalSEW.g:175:1: ruleUFI : ( ( rule__UFI__Group__0 ) ) ; |
| public final void ruleUFI() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:179:2: ( ( ( rule__UFI__Group__0 ) ) ) |
| // InternalSEW.g:180:2: ( ( rule__UFI__Group__0 ) ) |
| { |
| // InternalSEW.g:180:2: ( ( rule__UFI__Group__0 ) ) |
| // InternalSEW.g:181:3: ( rule__UFI__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUFIAccess().getGroup()); |
| } |
| // InternalSEW.g:182:3: ( rule__UFI__Group__0 ) |
| // InternalSEW.g:182:4: rule__UFI__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__UFI__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUFIAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleUFI" |
| |
| |
| // $ANTLR start "entryRuleObject" |
| // InternalSEW.g:191:1: entryRuleObject : ruleObject EOF ; |
| public final void entryRuleObject() throws RecognitionException { |
| try { |
| // InternalSEW.g:192:1: ( ruleObject EOF ) |
| // InternalSEW.g:193:1: ruleObject EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleObject" |
| |
| |
| // $ANTLR start "ruleObject" |
| // InternalSEW.g:200:1: ruleObject : ( ( rule__Object__Alternatives ) ) ; |
| public final void ruleObject() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:204:2: ( ( ( rule__Object__Alternatives ) ) ) |
| // InternalSEW.g:205:2: ( ( rule__Object__Alternatives ) ) |
| { |
| // InternalSEW.g:205:2: ( ( rule__Object__Alternatives ) ) |
| // InternalSEW.g:206:3: ( rule__Object__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getAlternatives()); |
| } |
| // InternalSEW.g:207:3: ( rule__Object__Alternatives ) |
| // InternalSEW.g:207:4: rule__Object__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleObject" |
| |
| |
| // $ANTLR start "entryRuleProperty" |
| // InternalSEW.g:216:1: entryRuleProperty : ruleProperty EOF ; |
| public final void entryRuleProperty() throws RecognitionException { |
| try { |
| // InternalSEW.g:217:1: ( ruleProperty EOF ) |
| // InternalSEW.g:218:1: ruleProperty EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleProperty(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleProperty" |
| |
| |
| // $ANTLR start "ruleProperty" |
| // InternalSEW.g:225:1: ruleProperty : ( ( rule__Property__Alternatives ) ) ; |
| public final void ruleProperty() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:229:2: ( ( ( rule__Property__Alternatives ) ) ) |
| // InternalSEW.g:230:2: ( ( rule__Property__Alternatives ) ) |
| { |
| // InternalSEW.g:230:2: ( ( rule__Property__Alternatives ) ) |
| // InternalSEW.g:231:3: ( rule__Property__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyAccess().getAlternatives()); |
| } |
| // InternalSEW.g:232:3: ( rule__Property__Alternatives ) |
| // InternalSEW.g:232:4: rule__Property__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Property__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleProperty" |
| |
| |
| // $ANTLR start "entryRuleSection" |
| // InternalSEW.g:241:1: entryRuleSection : ruleSection EOF ; |
| public final void entryRuleSection() throws RecognitionException { |
| try { |
| // InternalSEW.g:242:1: ( ruleSection EOF ) |
| // InternalSEW.g:243:1: ruleSection EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleSection(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleSection" |
| |
| |
| // $ANTLR start "ruleSection" |
| // InternalSEW.g:250:1: ruleSection : ( ( rule__Section__Group__0 ) ) ; |
| public final void ruleSection() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:254:2: ( ( ( rule__Section__Group__0 ) ) ) |
| // InternalSEW.g:255:2: ( ( rule__Section__Group__0 ) ) |
| { |
| // InternalSEW.g:255:2: ( ( rule__Section__Group__0 ) ) |
| // InternalSEW.g:256:3: ( rule__Section__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getGroup()); |
| } |
| // InternalSEW.g:257:3: ( rule__Section__Group__0 ) |
| // InternalSEW.g:257:4: rule__Section__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleSection" |
| |
| |
| // $ANTLR start "entryRuleAttribute" |
| // InternalSEW.g:266:1: entryRuleAttribute : ruleAttribute EOF ; |
| public final void entryRuleAttribute() throws RecognitionException { |
| try { |
| // InternalSEW.g:267:1: ( ruleAttribute EOF ) |
| // InternalSEW.g:268:1: ruleAttribute EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAttributeRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleAttribute(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAttributeRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleAttribute" |
| |
| |
| // $ANTLR start "ruleAttribute" |
| // InternalSEW.g:275:1: ruleAttribute : ( ( rule__Attribute__Group__0 ) ) ; |
| public final void ruleAttribute() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:279:2: ( ( ( rule__Attribute__Group__0 ) ) ) |
| // InternalSEW.g:280:2: ( ( rule__Attribute__Group__0 ) ) |
| { |
| // InternalSEW.g:280:2: ( ( rule__Attribute__Group__0 ) ) |
| // InternalSEW.g:281:3: ( rule__Attribute__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAttributeAccess().getGroup()); |
| } |
| // InternalSEW.g:282:3: ( rule__Attribute__Group__0 ) |
| // InternalSEW.g:282:4: rule__Attribute__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Attribute__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAttributeAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleAttribute" |
| |
| |
| // $ANTLR start "entryRuleValueSpecification" |
| // InternalSEW.g:291:1: entryRuleValueSpecification : ruleValueSpecification EOF ; |
| public final void entryRuleValueSpecification() throws RecognitionException { |
| try { |
| // InternalSEW.g:292:1: ( ruleValueSpecification EOF ) |
| // InternalSEW.g:293:1: ruleValueSpecification EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getValueSpecificationRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleValueSpecification(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getValueSpecificationRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleValueSpecification" |
| |
| |
| // $ANTLR start "ruleValueSpecification" |
| // InternalSEW.g:300:1: ruleValueSpecification : ( ruleExpression ) ; |
| public final void ruleValueSpecification() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:304:2: ( ( ruleExpression ) ) |
| // InternalSEW.g:305:2: ( ruleExpression ) |
| { |
| // InternalSEW.g:305:2: ( ruleExpression ) |
| // InternalSEW.g:306:3: ruleExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getValueSpecificationAccess().getExpressionParserRuleCall()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getValueSpecificationAccess().getExpressionParserRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleValueSpecification" |
| |
| |
| // $ANTLR start "entryRuleExpression" |
| // InternalSEW.g:316:1: entryRuleExpression : ruleExpression EOF ; |
| public final void entryRuleExpression() throws RecognitionException { |
| try { |
| // InternalSEW.g:317:1: ( ruleExpression EOF ) |
| // InternalSEW.g:318:1: ruleExpression EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpressionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpressionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleExpression" |
| |
| |
| // $ANTLR start "ruleExpression" |
| // InternalSEW.g:325:1: ruleExpression : ( ( rule__Expression__Alternatives ) ) ; |
| public final void ruleExpression() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:329:2: ( ( ( rule__Expression__Alternatives ) ) ) |
| // InternalSEW.g:330:2: ( ( rule__Expression__Alternatives ) ) |
| { |
| // InternalSEW.g:330:2: ( ( rule__Expression__Alternatives ) ) |
| // InternalSEW.g:331:3: ( rule__Expression__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpressionAccess().getAlternatives()); |
| } |
| // InternalSEW.g:332:3: ( rule__Expression__Alternatives ) |
| // InternalSEW.g:332:4: rule__Expression__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Expression__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpressionAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleExpression" |
| |
| |
| // $ANTLR start "entryRuleconditionalExpression" |
| // InternalSEW.g:341:1: entryRuleconditionalExpression : ruleconditionalExpression EOF ; |
| public final void entryRuleconditionalExpression() throws RecognitionException { |
| try { |
| // InternalSEW.g:342:1: ( ruleconditionalExpression EOF ) |
| // InternalSEW.g:343:1: ruleconditionalExpression EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleconditionalExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleconditionalExpression" |
| |
| |
| // $ANTLR start "ruleconditionalExpression" |
| // InternalSEW.g:350:1: ruleconditionalExpression : ( ( rule__ConditionalExpression__Group__0 ) ) ; |
| public final void ruleconditionalExpression() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:354:2: ( ( ( rule__ConditionalExpression__Group__0 ) ) ) |
| // InternalSEW.g:355:2: ( ( rule__ConditionalExpression__Group__0 ) ) |
| { |
| // InternalSEW.g:355:2: ( ( rule__ConditionalExpression__Group__0 ) ) |
| // InternalSEW.g:356:3: ( rule__ConditionalExpression__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getGroup()); |
| } |
| // InternalSEW.g:357:3: ( rule__ConditionalExpression__Group__0 ) |
| // InternalSEW.g:357:4: rule__ConditionalExpression__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleconditionalExpression" |
| |
| |
| // $ANTLR start "entryRuleconditionalOrExpression" |
| // InternalSEW.g:366:1: entryRuleconditionalOrExpression : ruleconditionalOrExpression EOF ; |
| public final void entryRuleconditionalOrExpression() throws RecognitionException { |
| try { |
| // InternalSEW.g:367:1: ( ruleconditionalOrExpression EOF ) |
| // InternalSEW.g:368:1: ruleconditionalOrExpression EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleconditionalOrExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleconditionalOrExpression" |
| |
| |
| // $ANTLR start "ruleconditionalOrExpression" |
| // InternalSEW.g:375:1: ruleconditionalOrExpression : ( ( rule__ConditionalOrExpression__Group__0 ) ) ; |
| public final void ruleconditionalOrExpression() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:379:2: ( ( ( rule__ConditionalOrExpression__Group__0 ) ) ) |
| // InternalSEW.g:380:2: ( ( rule__ConditionalOrExpression__Group__0 ) ) |
| { |
| // InternalSEW.g:380:2: ( ( rule__ConditionalOrExpression__Group__0 ) ) |
| // InternalSEW.g:381:3: ( rule__ConditionalOrExpression__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getGroup()); |
| } |
| // InternalSEW.g:382:3: ( rule__ConditionalOrExpression__Group__0 ) |
| // InternalSEW.g:382:4: rule__ConditionalOrExpression__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleconditionalOrExpression" |
| |
| |
| // $ANTLR start "entryRuleconditionalAndExpression" |
| // InternalSEW.g:391:1: entryRuleconditionalAndExpression : ruleconditionalAndExpression EOF ; |
| public final void entryRuleconditionalAndExpression() throws RecognitionException { |
| try { |
| // InternalSEW.g:392:1: ( ruleconditionalAndExpression EOF ) |
| // InternalSEW.g:393:1: ruleconditionalAndExpression EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleconditionalAndExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleconditionalAndExpression" |
| |
| |
| // $ANTLR start "ruleconditionalAndExpression" |
| // InternalSEW.g:400:1: ruleconditionalAndExpression : ( ( rule__ConditionalAndExpression__Group__0 ) ) ; |
| public final void ruleconditionalAndExpression() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:404:2: ( ( ( rule__ConditionalAndExpression__Group__0 ) ) ) |
| // InternalSEW.g:405:2: ( ( rule__ConditionalAndExpression__Group__0 ) ) |
| { |
| // InternalSEW.g:405:2: ( ( rule__ConditionalAndExpression__Group__0 ) ) |
| // InternalSEW.g:406:3: ( rule__ConditionalAndExpression__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getGroup()); |
| } |
| // InternalSEW.g:407:3: ( rule__ConditionalAndExpression__Group__0 ) |
| // InternalSEW.g:407:4: rule__ConditionalAndExpression__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleconditionalAndExpression" |
| |
| |
| // $ANTLR start "entryRuleequalityExpression" |
| // InternalSEW.g:416:1: entryRuleequalityExpression : ruleequalityExpression EOF ; |
| public final void entryRuleequalityExpression() throws RecognitionException { |
| try { |
| // InternalSEW.g:417:1: ( ruleequalityExpression EOF ) |
| // InternalSEW.g:418:1: ruleequalityExpression EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleequalityExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleequalityExpression" |
| |
| |
| // $ANTLR start "ruleequalityExpression" |
| // InternalSEW.g:425:1: ruleequalityExpression : ( ( rule__EqualityExpression__Group__0 ) ) ; |
| public final void ruleequalityExpression() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:429:2: ( ( ( rule__EqualityExpression__Group__0 ) ) ) |
| // InternalSEW.g:430:2: ( ( rule__EqualityExpression__Group__0 ) ) |
| { |
| // InternalSEW.g:430:2: ( ( rule__EqualityExpression__Group__0 ) ) |
| // InternalSEW.g:431:3: ( rule__EqualityExpression__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getGroup()); |
| } |
| // InternalSEW.g:432:3: ( rule__EqualityExpression__Group__0 ) |
| // InternalSEW.g:432:4: rule__EqualityExpression__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EqualityExpression__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleequalityExpression" |
| |
| |
| // $ANTLR start "entryRulerelationalExpression" |
| // InternalSEW.g:441:1: entryRulerelationalExpression : rulerelationalExpression EOF ; |
| public final void entryRulerelationalExpression() throws RecognitionException { |
| try { |
| // InternalSEW.g:442:1: ( rulerelationalExpression EOF ) |
| // InternalSEW.g:443:1: rulerelationalExpression EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| rulerelationalExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulerelationalExpression" |
| |
| |
| // $ANTLR start "rulerelationalExpression" |
| // InternalSEW.g:450:1: rulerelationalExpression : ( ( rule__RelationalExpression__Group__0 ) ) ; |
| public final void rulerelationalExpression() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:454:2: ( ( ( rule__RelationalExpression__Group__0 ) ) ) |
| // InternalSEW.g:455:2: ( ( rule__RelationalExpression__Group__0 ) ) |
| { |
| // InternalSEW.g:455:2: ( ( rule__RelationalExpression__Group__0 ) ) |
| // InternalSEW.g:456:3: ( rule__RelationalExpression__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getGroup()); |
| } |
| // InternalSEW.g:457:3: ( rule__RelationalExpression__Group__0 ) |
| // InternalSEW.g:457:4: rule__RelationalExpression__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RelationalExpression__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulerelationalExpression" |
| |
| |
| // $ANTLR start "entryRuleadditiveExpression" |
| // InternalSEW.g:466:1: entryRuleadditiveExpression : ruleadditiveExpression EOF ; |
| public final void entryRuleadditiveExpression() throws RecognitionException { |
| try { |
| // InternalSEW.g:467:1: ( ruleadditiveExpression EOF ) |
| // InternalSEW.g:468:1: ruleadditiveExpression EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleadditiveExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleadditiveExpression" |
| |
| |
| // $ANTLR start "ruleadditiveExpression" |
| // InternalSEW.g:475:1: ruleadditiveExpression : ( ( rule__AdditiveExpression__Group__0 ) ) ; |
| public final void ruleadditiveExpression() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:479:2: ( ( ( rule__AdditiveExpression__Group__0 ) ) ) |
| // InternalSEW.g:480:2: ( ( rule__AdditiveExpression__Group__0 ) ) |
| { |
| // InternalSEW.g:480:2: ( ( rule__AdditiveExpression__Group__0 ) ) |
| // InternalSEW.g:481:3: ( rule__AdditiveExpression__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getGroup()); |
| } |
| // InternalSEW.g:482:3: ( rule__AdditiveExpression__Group__0 ) |
| // InternalSEW.g:482:4: rule__AdditiveExpression__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleadditiveExpression" |
| |
| |
| // $ANTLR start "entryRulemultiplicativeExpression" |
| // InternalSEW.g:491:1: entryRulemultiplicativeExpression : rulemultiplicativeExpression EOF ; |
| public final void entryRulemultiplicativeExpression() throws RecognitionException { |
| try { |
| // InternalSEW.g:492:1: ( rulemultiplicativeExpression EOF ) |
| // InternalSEW.g:493:1: rulemultiplicativeExpression EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| rulemultiplicativeExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulemultiplicativeExpression" |
| |
| |
| // $ANTLR start "rulemultiplicativeExpression" |
| // InternalSEW.g:500:1: rulemultiplicativeExpression : ( ( rule__MultiplicativeExpression__Group__0 ) ) ; |
| public final void rulemultiplicativeExpression() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:504:2: ( ( ( rule__MultiplicativeExpression__Group__0 ) ) ) |
| // InternalSEW.g:505:2: ( ( rule__MultiplicativeExpression__Group__0 ) ) |
| { |
| // InternalSEW.g:505:2: ( ( rule__MultiplicativeExpression__Group__0 ) ) |
| // InternalSEW.g:506:3: ( rule__MultiplicativeExpression__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); |
| } |
| // InternalSEW.g:507:3: ( rule__MultiplicativeExpression__Group__0 ) |
| // InternalSEW.g:507:4: rule__MultiplicativeExpression__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulemultiplicativeExpression" |
| |
| |
| // $ANTLR start "entryRuleprimaryExpression" |
| // InternalSEW.g:516:1: entryRuleprimaryExpression : ruleprimaryExpression EOF ; |
| public final void entryRuleprimaryExpression() throws RecognitionException { |
| try { |
| // InternalSEW.g:517:1: ( ruleprimaryExpression EOF ) |
| // InternalSEW.g:518:1: ruleprimaryExpression EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleprimaryExpression" |
| |
| |
| // $ANTLR start "ruleprimaryExpression" |
| // InternalSEW.g:525:1: ruleprimaryExpression : ( ( rule__PrimaryExpression__Alternatives ) ) ; |
| public final void ruleprimaryExpression() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:529:2: ( ( ( rule__PrimaryExpression__Alternatives ) ) ) |
| // InternalSEW.g:530:2: ( ( rule__PrimaryExpression__Alternatives ) ) |
| { |
| // InternalSEW.g:530:2: ( ( rule__PrimaryExpression__Alternatives ) ) |
| // InternalSEW.g:531:3: ( rule__PrimaryExpression__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); |
| } |
| // InternalSEW.g:532:3: ( rule__PrimaryExpression__Alternatives ) |
| // InternalSEW.g:532:4: rule__PrimaryExpression__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleprimaryExpression" |
| |
| |
| // $ANTLR start "entryRuleLiteralExpression" |
| // InternalSEW.g:541:1: entryRuleLiteralExpression : ruleLiteralExpression EOF ; |
| public final void entryRuleLiteralExpression() throws RecognitionException { |
| try { |
| // InternalSEW.g:542:1: ( ruleLiteralExpression EOF ) |
| // InternalSEW.g:543:1: ruleLiteralExpression EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralExpression" |
| |
| |
| // $ANTLR start "ruleLiteralExpression" |
| // InternalSEW.g:550:1: ruleLiteralExpression : ( ( rule__LiteralExpression__Alternatives ) ) ; |
| public final void ruleLiteralExpression() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:554:2: ( ( ( rule__LiteralExpression__Alternatives ) ) ) |
| // InternalSEW.g:555:2: ( ( rule__LiteralExpression__Alternatives ) ) |
| { |
| // InternalSEW.g:555:2: ( ( rule__LiteralExpression__Alternatives ) ) |
| // InternalSEW.g:556:3: ( rule__LiteralExpression__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getAlternatives()); |
| } |
| // InternalSEW.g:557:3: ( rule__LiteralExpression__Alternatives ) |
| // InternalSEW.g:557:4: rule__LiteralExpression__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralExpression__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralExpression" |
| |
| |
| // $ANTLR start "entryRuleLiteralArrayValue" |
| // InternalSEW.g:566:1: entryRuleLiteralArrayValue : ruleLiteralArrayValue EOF ; |
| public final void entryRuleLiteralArrayValue() throws RecognitionException { |
| try { |
| // InternalSEW.g:567:1: ( ruleLiteralArrayValue EOF ) |
| // InternalSEW.g:568:1: ruleLiteralArrayValue EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralArrayValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralArrayValue" |
| |
| |
| // $ANTLR start "ruleLiteralArrayValue" |
| // InternalSEW.g:575:1: ruleLiteralArrayValue : ( ( rule__LiteralArrayValue__Group__0 ) ) ; |
| public final void ruleLiteralArrayValue() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:579:2: ( ( ( rule__LiteralArrayValue__Group__0 ) ) ) |
| // InternalSEW.g:580:2: ( ( rule__LiteralArrayValue__Group__0 ) ) |
| { |
| // InternalSEW.g:580:2: ( ( rule__LiteralArrayValue__Group__0 ) ) |
| // InternalSEW.g:581:3: ( rule__LiteralArrayValue__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueAccess().getGroup()); |
| } |
| // InternalSEW.g:582:3: ( rule__LiteralArrayValue__Group__0 ) |
| // InternalSEW.g:582:4: rule__LiteralArrayValue__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralArrayValue" |
| |
| |
| // $ANTLR start "entryRuleLiteralObjectReference" |
| // InternalSEW.g:591:1: entryRuleLiteralObjectReference : ruleLiteralObjectReference EOF ; |
| public final void entryRuleLiteralObjectReference() throws RecognitionException { |
| try { |
| // InternalSEW.g:592:1: ( ruleLiteralObjectReference EOF ) |
| // InternalSEW.g:593:1: ruleLiteralObjectReference EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralObjectReferenceRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralObjectReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralObjectReferenceRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralObjectReference" |
| |
| |
| // $ANTLR start "ruleLiteralObjectReference" |
| // InternalSEW.g:600:1: ruleLiteralObjectReference : ( ( rule__LiteralObjectReference__Group__0 ) ) ; |
| public final void ruleLiteralObjectReference() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:604:2: ( ( ( rule__LiteralObjectReference__Group__0 ) ) ) |
| // InternalSEW.g:605:2: ( ( rule__LiteralObjectReference__Group__0 ) ) |
| { |
| // InternalSEW.g:605:2: ( ( rule__LiteralObjectReference__Group__0 ) ) |
| // InternalSEW.g:606:3: ( rule__LiteralObjectReference__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralObjectReferenceAccess().getGroup()); |
| } |
| // InternalSEW.g:607:3: ( rule__LiteralObjectReference__Group__0 ) |
| // InternalSEW.g:607:4: rule__LiteralObjectReference__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralObjectReference__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralObjectReferenceAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralObjectReference" |
| |
| |
| // $ANTLR start "entryRuleLiteralBooleanValue" |
| // InternalSEW.g:616:1: entryRuleLiteralBooleanValue : ruleLiteralBooleanValue EOF ; |
| public final void entryRuleLiteralBooleanValue() throws RecognitionException { |
| try { |
| // InternalSEW.g:617:1: ( ruleLiteralBooleanValue EOF ) |
| // InternalSEW.g:618:1: ruleLiteralBooleanValue EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralBooleanValueRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralBooleanValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralBooleanValueRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralBooleanValue" |
| |
| |
| // $ANTLR start "ruleLiteralBooleanValue" |
| // InternalSEW.g:625:1: ruleLiteralBooleanValue : ( ( rule__LiteralBooleanValue__ValueAssignment ) ) ; |
| public final void ruleLiteralBooleanValue() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:629:2: ( ( ( rule__LiteralBooleanValue__ValueAssignment ) ) ) |
| // InternalSEW.g:630:2: ( ( rule__LiteralBooleanValue__ValueAssignment ) ) |
| { |
| // InternalSEW.g:630:2: ( ( rule__LiteralBooleanValue__ValueAssignment ) ) |
| // InternalSEW.g:631:3: ( rule__LiteralBooleanValue__ValueAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralBooleanValueAccess().getValueAssignment()); |
| } |
| // InternalSEW.g:632:3: ( rule__LiteralBooleanValue__ValueAssignment ) |
| // InternalSEW.g:632:4: rule__LiteralBooleanValue__ValueAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralBooleanValue__ValueAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralBooleanValueAccess().getValueAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralBooleanValue" |
| |
| |
| // $ANTLR start "entryRuleLiteralCharacterValue" |
| // InternalSEW.g:641:1: entryRuleLiteralCharacterValue : ruleLiteralCharacterValue EOF ; |
| public final void entryRuleLiteralCharacterValue() throws RecognitionException { |
| try { |
| // InternalSEW.g:642:1: ( ruleLiteralCharacterValue EOF ) |
| // InternalSEW.g:643:1: ruleLiteralCharacterValue EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralCharacterValueRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralCharacterValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralCharacterValueRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralCharacterValue" |
| |
| |
| // $ANTLR start "ruleLiteralCharacterValue" |
| // InternalSEW.g:650:1: ruleLiteralCharacterValue : ( ( rule__LiteralCharacterValue__ValueAssignment ) ) ; |
| public final void ruleLiteralCharacterValue() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:654:2: ( ( ( rule__LiteralCharacterValue__ValueAssignment ) ) ) |
| // InternalSEW.g:655:2: ( ( rule__LiteralCharacterValue__ValueAssignment ) ) |
| { |
| // InternalSEW.g:655:2: ( ( rule__LiteralCharacterValue__ValueAssignment ) ) |
| // InternalSEW.g:656:3: ( rule__LiteralCharacterValue__ValueAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralCharacterValueAccess().getValueAssignment()); |
| } |
| // InternalSEW.g:657:3: ( rule__LiteralCharacterValue__ValueAssignment ) |
| // InternalSEW.g:657:4: rule__LiteralCharacterValue__ValueAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralCharacterValue__ValueAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralCharacterValueAccess().getValueAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralCharacterValue" |
| |
| |
| // $ANTLR start "entryRuleLiteralIntegerValue" |
| // InternalSEW.g:666:1: entryRuleLiteralIntegerValue : ruleLiteralIntegerValue EOF ; |
| public final void entryRuleLiteralIntegerValue() throws RecognitionException { |
| try { |
| // InternalSEW.g:667:1: ( ruleLiteralIntegerValue EOF ) |
| // InternalSEW.g:668:1: ruleLiteralIntegerValue EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralIntegerValueRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralIntegerValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralIntegerValueRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralIntegerValue" |
| |
| |
| // $ANTLR start "ruleLiteralIntegerValue" |
| // InternalSEW.g:675:1: ruleLiteralIntegerValue : ( ( rule__LiteralIntegerValue__ValueAssignment ) ) ; |
| public final void ruleLiteralIntegerValue() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:679:2: ( ( ( rule__LiteralIntegerValue__ValueAssignment ) ) ) |
| // InternalSEW.g:680:2: ( ( rule__LiteralIntegerValue__ValueAssignment ) ) |
| { |
| // InternalSEW.g:680:2: ( ( rule__LiteralIntegerValue__ValueAssignment ) ) |
| // InternalSEW.g:681:3: ( rule__LiteralIntegerValue__ValueAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralIntegerValueAccess().getValueAssignment()); |
| } |
| // InternalSEW.g:682:3: ( rule__LiteralIntegerValue__ValueAssignment ) |
| // InternalSEW.g:682:4: rule__LiteralIntegerValue__ValueAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralIntegerValue__ValueAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralIntegerValueAccess().getValueAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralIntegerValue" |
| |
| |
| // $ANTLR start "entryRuleLiteralRationalValue" |
| // InternalSEW.g:691:1: entryRuleLiteralRationalValue : ruleLiteralRationalValue EOF ; |
| public final void entryRuleLiteralRationalValue() throws RecognitionException { |
| try { |
| // InternalSEW.g:692:1: ( ruleLiteralRationalValue EOF ) |
| // InternalSEW.g:693:1: ruleLiteralRationalValue EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralRationalValueRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralRationalValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralRationalValueRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralRationalValue" |
| |
| |
| // $ANTLR start "ruleLiteralRationalValue" |
| // InternalSEW.g:700:1: ruleLiteralRationalValue : ( ( rule__LiteralRationalValue__Group__0 ) ) ; |
| public final void ruleLiteralRationalValue() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:704:2: ( ( ( rule__LiteralRationalValue__Group__0 ) ) ) |
| // InternalSEW.g:705:2: ( ( rule__LiteralRationalValue__Group__0 ) ) |
| { |
| // InternalSEW.g:705:2: ( ( rule__LiteralRationalValue__Group__0 ) ) |
| // InternalSEW.g:706:3: ( rule__LiteralRationalValue__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralRationalValueAccess().getGroup()); |
| } |
| // InternalSEW.g:707:3: ( rule__LiteralRationalValue__Group__0 ) |
| // InternalSEW.g:707:4: rule__LiteralRationalValue__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralRationalValue__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralRationalValueAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralRationalValue" |
| |
| |
| // $ANTLR start "entryRuleLiteralFloatValue" |
| // InternalSEW.g:716:1: entryRuleLiteralFloatValue : ruleLiteralFloatValue EOF ; |
| public final void entryRuleLiteralFloatValue() throws RecognitionException { |
| try { |
| // InternalSEW.g:717:1: ( ruleLiteralFloatValue EOF ) |
| // InternalSEW.g:718:1: ruleLiteralFloatValue EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralFloatValueRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralFloatValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralFloatValueRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralFloatValue" |
| |
| |
| // $ANTLR start "ruleLiteralFloatValue" |
| // InternalSEW.g:725:1: ruleLiteralFloatValue : ( ( rule__LiteralFloatValue__ValueAssignment ) ) ; |
| public final void ruleLiteralFloatValue() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:729:2: ( ( ( rule__LiteralFloatValue__ValueAssignment ) ) ) |
| // InternalSEW.g:730:2: ( ( rule__LiteralFloatValue__ValueAssignment ) ) |
| { |
| // InternalSEW.g:730:2: ( ( rule__LiteralFloatValue__ValueAssignment ) ) |
| // InternalSEW.g:731:3: ( rule__LiteralFloatValue__ValueAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralFloatValueAccess().getValueAssignment()); |
| } |
| // InternalSEW.g:732:3: ( rule__LiteralFloatValue__ValueAssignment ) |
| // InternalSEW.g:732:4: rule__LiteralFloatValue__ValueAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralFloatValue__ValueAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralFloatValueAccess().getValueAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralFloatValue" |
| |
| |
| // $ANTLR start "entryRuleLiteralStringValue" |
| // InternalSEW.g:741:1: entryRuleLiteralStringValue : ruleLiteralStringValue EOF ; |
| public final void entryRuleLiteralStringValue() throws RecognitionException { |
| try { |
| // InternalSEW.g:742:1: ( ruleLiteralStringValue EOF ) |
| // InternalSEW.g:743:1: ruleLiteralStringValue EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralStringValueRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralStringValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralStringValueRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralStringValue" |
| |
| |
| // $ANTLR start "ruleLiteralStringValue" |
| // InternalSEW.g:750:1: ruleLiteralStringValue : ( ( rule__LiteralStringValue__ValueAssignment ) ) ; |
| public final void ruleLiteralStringValue() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:754:2: ( ( ( rule__LiteralStringValue__ValueAssignment ) ) ) |
| // InternalSEW.g:755:2: ( ( rule__LiteralStringValue__ValueAssignment ) ) |
| { |
| // InternalSEW.g:755:2: ( ( rule__LiteralStringValue__ValueAssignment ) ) |
| // InternalSEW.g:756:3: ( rule__LiteralStringValue__ValueAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralStringValueAccess().getValueAssignment()); |
| } |
| // InternalSEW.g:757:3: ( rule__LiteralStringValue__ValueAssignment ) |
| // InternalSEW.g:757:4: rule__LiteralStringValue__ValueAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralStringValue__ValueAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralStringValueAccess().getValueAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralStringValue" |
| |
| |
| // $ANTLR start "entryRuleLiteralNullValue" |
| // InternalSEW.g:766:1: entryRuleLiteralNullValue : ruleLiteralNullValue EOF ; |
| public final void entryRuleLiteralNullValue() throws RecognitionException { |
| try { |
| // InternalSEW.g:767:1: ( ruleLiteralNullValue EOF ) |
| // InternalSEW.g:768:1: ruleLiteralNullValue EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralNullValueRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralNullValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralNullValueRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralNullValue" |
| |
| |
| // $ANTLR start "ruleLiteralNullValue" |
| // InternalSEW.g:775:1: ruleLiteralNullValue : ( ( rule__LiteralNullValue__Group__0 ) ) ; |
| public final void ruleLiteralNullValue() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:779:2: ( ( ( rule__LiteralNullValue__Group__0 ) ) ) |
| // InternalSEW.g:780:2: ( ( rule__LiteralNullValue__Group__0 ) ) |
| { |
| // InternalSEW.g:780:2: ( ( rule__LiteralNullValue__Group__0 ) ) |
| // InternalSEW.g:781:3: ( rule__LiteralNullValue__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralNullValueAccess().getGroup()); |
| } |
| // InternalSEW.g:782:3: ( rule__LiteralNullValue__Group__0 ) |
| // InternalSEW.g:782:4: rule__LiteralNullValue__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralNullValue__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralNullValueAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralNullValue" |
| |
| |
| // $ANTLR start "entryRuleLiteralVariableReference" |
| // InternalSEW.g:791:1: entryRuleLiteralVariableReference : ruleLiteralVariableReference EOF ; |
| public final void entryRuleLiteralVariableReference() throws RecognitionException { |
| try { |
| // InternalSEW.g:792:1: ( ruleLiteralVariableReference EOF ) |
| // InternalSEW.g:793:1: ruleLiteralVariableReference EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralVariableReferenceRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralVariableReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralVariableReferenceRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralVariableReference" |
| |
| |
| // $ANTLR start "ruleLiteralVariableReference" |
| // InternalSEW.g:800:1: ruleLiteralVariableReference : ( ( rule__LiteralVariableReference__Alternatives ) ) ; |
| public final void ruleLiteralVariableReference() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:804:2: ( ( ( rule__LiteralVariableReference__Alternatives ) ) ) |
| // InternalSEW.g:805:2: ( ( rule__LiteralVariableReference__Alternatives ) ) |
| { |
| // InternalSEW.g:805:2: ( ( rule__LiteralVariableReference__Alternatives ) ) |
| // InternalSEW.g:806:3: ( rule__LiteralVariableReference__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralVariableReferenceAccess().getAlternatives()); |
| } |
| // InternalSEW.g:807:3: ( rule__LiteralVariableReference__Alternatives ) |
| // InternalSEW.g:807:4: rule__LiteralVariableReference__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralVariableReference__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralVariableReferenceAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralVariableReference" |
| |
| |
| // $ANTLR start "entryRuleLiteralTimeVariable" |
| // InternalSEW.g:816:1: entryRuleLiteralTimeVariable : ruleLiteralTimeVariable EOF ; |
| public final void entryRuleLiteralTimeVariable() throws RecognitionException { |
| try { |
| // InternalSEW.g:817:1: ( ruleLiteralTimeVariable EOF ) |
| // InternalSEW.g:818:1: ruleLiteralTimeVariable EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeVariableRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralTimeVariable(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeVariableRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralTimeVariable" |
| |
| |
| // $ANTLR start "ruleLiteralTimeVariable" |
| // InternalSEW.g:825:1: ruleLiteralTimeVariable : ( ( rule__LiteralTimeVariable__Group__0 ) ) ; |
| public final void ruleLiteralTimeVariable() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:829:2: ( ( ( rule__LiteralTimeVariable__Group__0 ) ) ) |
| // InternalSEW.g:830:2: ( ( rule__LiteralTimeVariable__Group__0 ) ) |
| { |
| // InternalSEW.g:830:2: ( ( rule__LiteralTimeVariable__Group__0 ) ) |
| // InternalSEW.g:831:3: ( rule__LiteralTimeVariable__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeVariableAccess().getGroup()); |
| } |
| // InternalSEW.g:832:3: ( rule__LiteralTimeVariable__Group__0 ) |
| // InternalSEW.g:832:4: rule__LiteralTimeVariable__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralTimeVariable__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeVariableAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralTimeVariable" |
| |
| |
| // $ANTLR start "entryRuleLiteralTimeDeltaVariable" |
| // InternalSEW.g:841:1: entryRuleLiteralTimeDeltaVariable : ruleLiteralTimeDeltaVariable EOF ; |
| public final void entryRuleLiteralTimeDeltaVariable() throws RecognitionException { |
| try { |
| // InternalSEW.g:842:1: ( ruleLiteralTimeDeltaVariable EOF ) |
| // InternalSEW.g:843:1: ruleLiteralTimeDeltaVariable EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeDeltaVariableRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralTimeDeltaVariable(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeDeltaVariableRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralTimeDeltaVariable" |
| |
| |
| // $ANTLR start "ruleLiteralTimeDeltaVariable" |
| // InternalSEW.g:850:1: ruleLiteralTimeDeltaVariable : ( ( rule__LiteralTimeDeltaVariable__Group__0 ) ) ; |
| public final void ruleLiteralTimeDeltaVariable() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:854:2: ( ( ( rule__LiteralTimeDeltaVariable__Group__0 ) ) ) |
| // InternalSEW.g:855:2: ( ( rule__LiteralTimeDeltaVariable__Group__0 ) ) |
| { |
| // InternalSEW.g:855:2: ( ( rule__LiteralTimeDeltaVariable__Group__0 ) ) |
| // InternalSEW.g:856:3: ( rule__LiteralTimeDeltaVariable__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeDeltaVariableAccess().getGroup()); |
| } |
| // InternalSEW.g:857:3: ( rule__LiteralTimeDeltaVariable__Group__0 ) |
| // InternalSEW.g:857:4: rule__LiteralTimeDeltaVariable__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralTimeDeltaVariable__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeDeltaVariableAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralTimeDeltaVariable" |
| |
| |
| // $ANTLR start "entryRuleLiteralInstanceReference" |
| // InternalSEW.g:866:1: entryRuleLiteralInstanceReference : ruleLiteralInstanceReference EOF ; |
| public final void entryRuleLiteralInstanceReference() throws RecognitionException { |
| try { |
| // InternalSEW.g:867:1: ( ruleLiteralInstanceReference EOF ) |
| // InternalSEW.g:868:1: ruleLiteralInstanceReference EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralInstanceReferenceRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralInstanceReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralInstanceReferenceRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralInstanceReference" |
| |
| |
| // $ANTLR start "ruleLiteralInstanceReference" |
| // InternalSEW.g:875:1: ruleLiteralInstanceReference : ( ( rule__LiteralInstanceReference__Alternatives ) ) ; |
| public final void ruleLiteralInstanceReference() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:879:2: ( ( ( rule__LiteralInstanceReference__Alternatives ) ) ) |
| // InternalSEW.g:880:2: ( ( rule__LiteralInstanceReference__Alternatives ) ) |
| { |
| // InternalSEW.g:880:2: ( ( rule__LiteralInstanceReference__Alternatives ) ) |
| // InternalSEW.g:881:3: ( rule__LiteralInstanceReference__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralInstanceReferenceAccess().getAlternatives()); |
| } |
| // InternalSEW.g:882:3: ( rule__LiteralInstanceReference__Alternatives ) |
| // InternalSEW.g:882:4: rule__LiteralInstanceReference__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralInstanceReference__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralInstanceReferenceAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralInstanceReference" |
| |
| |
| // $ANTLR start "entryRuleLiteralThisInstance" |
| // InternalSEW.g:891:1: entryRuleLiteralThisInstance : ruleLiteralThisInstance EOF ; |
| public final void entryRuleLiteralThisInstance() throws RecognitionException { |
| try { |
| // InternalSEW.g:892:1: ( ruleLiteralThisInstance EOF ) |
| // InternalSEW.g:893:1: ruleLiteralThisInstance EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralThisInstanceRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralThisInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralThisInstanceRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralThisInstance" |
| |
| |
| // $ANTLR start "ruleLiteralThisInstance" |
| // InternalSEW.g:900:1: ruleLiteralThisInstance : ( ( rule__LiteralThisInstance__Group__0 ) ) ; |
| public final void ruleLiteralThisInstance() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:904:2: ( ( ( rule__LiteralThisInstance__Group__0 ) ) ) |
| // InternalSEW.g:905:2: ( ( rule__LiteralThisInstance__Group__0 ) ) |
| { |
| // InternalSEW.g:905:2: ( ( rule__LiteralThisInstance__Group__0 ) ) |
| // InternalSEW.g:906:3: ( rule__LiteralThisInstance__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralThisInstanceAccess().getGroup()); |
| } |
| // InternalSEW.g:907:3: ( rule__LiteralThisInstance__Group__0 ) |
| // InternalSEW.g:907:4: rule__LiteralThisInstance__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralThisInstance__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralThisInstanceAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralThisInstance" |
| |
| |
| // $ANTLR start "entryRuleLiteralSelfInstance" |
| // InternalSEW.g:916:1: entryRuleLiteralSelfInstance : ruleLiteralSelfInstance EOF ; |
| public final void entryRuleLiteralSelfInstance() throws RecognitionException { |
| try { |
| // InternalSEW.g:917:1: ( ruleLiteralSelfInstance EOF ) |
| // InternalSEW.g:918:1: ruleLiteralSelfInstance EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSelfInstanceRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralSelfInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSelfInstanceRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralSelfInstance" |
| |
| |
| // $ANTLR start "ruleLiteralSelfInstance" |
| // InternalSEW.g:925:1: ruleLiteralSelfInstance : ( ( rule__LiteralSelfInstance__Group__0 ) ) ; |
| public final void ruleLiteralSelfInstance() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:929:2: ( ( ( rule__LiteralSelfInstance__Group__0 ) ) ) |
| // InternalSEW.g:930:2: ( ( rule__LiteralSelfInstance__Group__0 ) ) |
| { |
| // InternalSEW.g:930:2: ( ( rule__LiteralSelfInstance__Group__0 ) ) |
| // InternalSEW.g:931:3: ( rule__LiteralSelfInstance__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSelfInstanceAccess().getGroup()); |
| } |
| // InternalSEW.g:932:3: ( rule__LiteralSelfInstance__Group__0 ) |
| // InternalSEW.g:932:4: rule__LiteralSelfInstance__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSelfInstance__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSelfInstanceAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralSelfInstance" |
| |
| |
| // $ANTLR start "entryRuleLiteralParentInstance" |
| // InternalSEW.g:941:1: entryRuleLiteralParentInstance : ruleLiteralParentInstance EOF ; |
| public final void entryRuleLiteralParentInstance() throws RecognitionException { |
| try { |
| // InternalSEW.g:942:1: ( ruleLiteralParentInstance EOF ) |
| // InternalSEW.g:943:1: ruleLiteralParentInstance EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralParentInstanceRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralParentInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralParentInstanceRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralParentInstance" |
| |
| |
| // $ANTLR start "ruleLiteralParentInstance" |
| // InternalSEW.g:950:1: ruleLiteralParentInstance : ( ( rule__LiteralParentInstance__Group__0 ) ) ; |
| public final void ruleLiteralParentInstance() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:954:2: ( ( ( rule__LiteralParentInstance__Group__0 ) ) ) |
| // InternalSEW.g:955:2: ( ( rule__LiteralParentInstance__Group__0 ) ) |
| { |
| // InternalSEW.g:955:2: ( ( rule__LiteralParentInstance__Group__0 ) ) |
| // InternalSEW.g:956:3: ( rule__LiteralParentInstance__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralParentInstanceAccess().getGroup()); |
| } |
| // InternalSEW.g:957:3: ( rule__LiteralParentInstance__Group__0 ) |
| // InternalSEW.g:957:4: rule__LiteralParentInstance__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralParentInstance__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralParentInstanceAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralParentInstance" |
| |
| |
| // $ANTLR start "entryRuleLiteralSuperInstance" |
| // InternalSEW.g:966:1: entryRuleLiteralSuperInstance : ruleLiteralSuperInstance EOF ; |
| public final void entryRuleLiteralSuperInstance() throws RecognitionException { |
| try { |
| // InternalSEW.g:967:1: ( ruleLiteralSuperInstance EOF ) |
| // InternalSEW.g:968:1: ruleLiteralSuperInstance EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSuperInstanceRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralSuperInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSuperInstanceRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralSuperInstance" |
| |
| |
| // $ANTLR start "ruleLiteralSuperInstance" |
| // InternalSEW.g:975:1: ruleLiteralSuperInstance : ( ( rule__LiteralSuperInstance__Group__0 ) ) ; |
| public final void ruleLiteralSuperInstance() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:979:2: ( ( ( rule__LiteralSuperInstance__Group__0 ) ) ) |
| // InternalSEW.g:980:2: ( ( rule__LiteralSuperInstance__Group__0 ) ) |
| { |
| // InternalSEW.g:980:2: ( ( rule__LiteralSuperInstance__Group__0 ) ) |
| // InternalSEW.g:981:3: ( rule__LiteralSuperInstance__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSuperInstanceAccess().getGroup()); |
| } |
| // InternalSEW.g:982:3: ( rule__LiteralSuperInstance__Group__0 ) |
| // InternalSEW.g:982:4: rule__LiteralSuperInstance__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSuperInstance__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSuperInstanceAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralSuperInstance" |
| |
| |
| // $ANTLR start "entryRuleLiteralSystemInstance" |
| // InternalSEW.g:991:1: entryRuleLiteralSystemInstance : ruleLiteralSystemInstance EOF ; |
| public final void entryRuleLiteralSystemInstance() throws RecognitionException { |
| try { |
| // InternalSEW.g:992:1: ( ruleLiteralSystemInstance EOF ) |
| // InternalSEW.g:993:1: ruleLiteralSystemInstance EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSystemInstanceRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralSystemInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSystemInstanceRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralSystemInstance" |
| |
| |
| // $ANTLR start "ruleLiteralSystemInstance" |
| // InternalSEW.g:1000:1: ruleLiteralSystemInstance : ( ( rule__LiteralSystemInstance__Group__0 ) ) ; |
| public final void ruleLiteralSystemInstance() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1004:2: ( ( ( rule__LiteralSystemInstance__Group__0 ) ) ) |
| // InternalSEW.g:1005:2: ( ( rule__LiteralSystemInstance__Group__0 ) ) |
| { |
| // InternalSEW.g:1005:2: ( ( rule__LiteralSystemInstance__Group__0 ) ) |
| // InternalSEW.g:1006:3: ( rule__LiteralSystemInstance__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSystemInstanceAccess().getGroup()); |
| } |
| // InternalSEW.g:1007:3: ( rule__LiteralSystemInstance__Group__0 ) |
| // InternalSEW.g:1007:4: rule__LiteralSystemInstance__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSystemInstance__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSystemInstanceAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralSystemInstance" |
| |
| |
| // $ANTLR start "entryRuleLiteralEnvInstance" |
| // InternalSEW.g:1016:1: entryRuleLiteralEnvInstance : ruleLiteralEnvInstance EOF ; |
| public final void entryRuleLiteralEnvInstance() throws RecognitionException { |
| try { |
| // InternalSEW.g:1017:1: ( ruleLiteralEnvInstance EOF ) |
| // InternalSEW.g:1018:1: ruleLiteralEnvInstance EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralEnvInstanceRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLiteralEnvInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralEnvInstanceRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteralEnvInstance" |
| |
| |
| // $ANTLR start "ruleLiteralEnvInstance" |
| // InternalSEW.g:1025:1: ruleLiteralEnvInstance : ( ( rule__LiteralEnvInstance__Group__0 ) ) ; |
| public final void ruleLiteralEnvInstance() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1029:2: ( ( ( rule__LiteralEnvInstance__Group__0 ) ) ) |
| // InternalSEW.g:1030:2: ( ( rule__LiteralEnvInstance__Group__0 ) ) |
| { |
| // InternalSEW.g:1030:2: ( ( rule__LiteralEnvInstance__Group__0 ) ) |
| // InternalSEW.g:1031:3: ( rule__LiteralEnvInstance__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralEnvInstanceAccess().getGroup()); |
| } |
| // InternalSEW.g:1032:3: ( rule__LiteralEnvInstance__Group__0 ) |
| // InternalSEW.g:1032:4: rule__LiteralEnvInstance__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralEnvInstance__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralEnvInstanceAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralEnvInstance" |
| |
| |
| // $ANTLR start "entryRuleEBoolean" |
| // InternalSEW.g:1041:1: entryRuleEBoolean : ruleEBoolean EOF ; |
| public final void entryRuleEBoolean() throws RecognitionException { |
| try { |
| // InternalSEW.g:1042:1: ( ruleEBoolean EOF ) |
| // InternalSEW.g:1043:1: ruleEBoolean EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEBooleanRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleEBoolean(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEBooleanRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEBoolean" |
| |
| |
| // $ANTLR start "ruleEBoolean" |
| // InternalSEW.g:1050:1: ruleEBoolean : ( ( rule__EBoolean__Alternatives ) ) ; |
| public final void ruleEBoolean() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1054:2: ( ( ( rule__EBoolean__Alternatives ) ) ) |
| // InternalSEW.g:1055:2: ( ( rule__EBoolean__Alternatives ) ) |
| { |
| // InternalSEW.g:1055:2: ( ( rule__EBoolean__Alternatives ) ) |
| // InternalSEW.g:1056:3: ( rule__EBoolean__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEBooleanAccess().getAlternatives()); |
| } |
| // InternalSEW.g:1057:3: ( rule__EBoolean__Alternatives ) |
| // InternalSEW.g:1057:4: rule__EBoolean__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EBoolean__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEBooleanAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEBoolean" |
| |
| |
| // $ANTLR start "entryRuleEChar" |
| // InternalSEW.g:1066:1: entryRuleEChar : ruleEChar EOF ; |
| public final void entryRuleEChar() throws RecognitionException { |
| try { |
| // InternalSEW.g:1067:1: ( ruleEChar EOF ) |
| // InternalSEW.g:1068:1: ruleEChar EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getECharRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleEChar(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getECharRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEChar" |
| |
| |
| // $ANTLR start "ruleEChar" |
| // InternalSEW.g:1075:1: ruleEChar : ( RULE_CHARACTER ) ; |
| public final void ruleEChar() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1079:2: ( ( RULE_CHARACTER ) ) |
| // InternalSEW.g:1080:2: ( RULE_CHARACTER ) |
| { |
| // InternalSEW.g:1080:2: ( RULE_CHARACTER ) |
| // InternalSEW.g:1081:3: RULE_CHARACTER |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getECharAccess().getCHARACTERTerminalRuleCall()); |
| } |
| match(input,RULE_CHARACTER,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getECharAccess().getCHARACTERTerminalRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEChar" |
| |
| |
| // $ANTLR start "entryRuleELong" |
| // InternalSEW.g:1091:1: entryRuleELong : ruleELong EOF ; |
| public final void entryRuleELong() throws RecognitionException { |
| try { |
| // InternalSEW.g:1092:1: ( ruleELong EOF ) |
| // InternalSEW.g:1093:1: ruleELong EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getELongRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleELong(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getELongRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleELong" |
| |
| |
| // $ANTLR start "ruleELong" |
| // InternalSEW.g:1100:1: ruleELong : ( ( rule__ELong__Group__0 ) ) ; |
| public final void ruleELong() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1104:2: ( ( ( rule__ELong__Group__0 ) ) ) |
| // InternalSEW.g:1105:2: ( ( rule__ELong__Group__0 ) ) |
| { |
| // InternalSEW.g:1105:2: ( ( rule__ELong__Group__0 ) ) |
| // InternalSEW.g:1106:3: ( rule__ELong__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getELongAccess().getGroup()); |
| } |
| // InternalSEW.g:1107:3: ( rule__ELong__Group__0 ) |
| // InternalSEW.g:1107:4: rule__ELong__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ELong__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getELongAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleELong" |
| |
| |
| // $ANTLR start "entryRuleEDouble" |
| // InternalSEW.g:1116:1: entryRuleEDouble : ruleEDouble EOF ; |
| public final void entryRuleEDouble() throws RecognitionException { |
| try { |
| // InternalSEW.g:1117:1: ( ruleEDouble EOF ) |
| // InternalSEW.g:1118:1: ruleEDouble EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEDoubleRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleEDouble(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEDoubleRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEDouble" |
| |
| |
| // $ANTLR start "ruleEDouble" |
| // InternalSEW.g:1125:1: ruleEDouble : ( ( rule__EDouble__Group__0 ) ) ; |
| public final void ruleEDouble() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1129:2: ( ( ( rule__EDouble__Group__0 ) ) ) |
| // InternalSEW.g:1130:2: ( ( rule__EDouble__Group__0 ) ) |
| { |
| // InternalSEW.g:1130:2: ( ( rule__EDouble__Group__0 ) ) |
| // InternalSEW.g:1131:3: ( rule__EDouble__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEDoubleAccess().getGroup()); |
| } |
| // InternalSEW.g:1132:3: ( rule__EDouble__Group__0 ) |
| // InternalSEW.g:1132:4: rule__EDouble__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EDouble__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEDoubleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEDouble" |
| |
| |
| // $ANTLR start "entryRuleEBigDecimal" |
| // InternalSEW.g:1141:1: entryRuleEBigDecimal : ruleEBigDecimal EOF ; |
| public final void entryRuleEBigDecimal() throws RecognitionException { |
| try { |
| // InternalSEW.g:1142:1: ( ruleEBigDecimal EOF ) |
| // InternalSEW.g:1143:1: ruleEBigDecimal EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEBigDecimalRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleEBigDecimal(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEBigDecimalRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEBigDecimal" |
| |
| |
| // $ANTLR start "ruleEBigDecimal" |
| // InternalSEW.g:1150:1: ruleEBigDecimal : ( ( rule__EBigDecimal__Group__0 ) ) ; |
| public final void ruleEBigDecimal() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1154:2: ( ( ( rule__EBigDecimal__Group__0 ) ) ) |
| // InternalSEW.g:1155:2: ( ( rule__EBigDecimal__Group__0 ) ) |
| { |
| // InternalSEW.g:1155:2: ( ( rule__EBigDecimal__Group__0 ) ) |
| // InternalSEW.g:1156:3: ( rule__EBigDecimal__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEBigDecimalAccess().getGroup()); |
| } |
| // InternalSEW.g:1157:3: ( rule__EBigDecimal__Group__0 ) |
| // InternalSEW.g:1157:4: rule__EBigDecimal__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EBigDecimal__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEBigDecimalAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEBigDecimal" |
| |
| |
| // $ANTLR start "entryRuleEString" |
| // InternalSEW.g:1166:1: entryRuleEString : ruleEString EOF ; |
| public final void entryRuleEString() throws RecognitionException { |
| try { |
| // InternalSEW.g:1167:1: ( ruleEString EOF ) |
| // InternalSEW.g:1168:1: ruleEString EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEStringRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleEString(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEStringRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEString" |
| |
| |
| // $ANTLR start "ruleEString" |
| // InternalSEW.g:1175:1: ruleEString : ( RULE_STRING ) ; |
| public final void ruleEString() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1179:2: ( ( RULE_STRING ) ) |
| // InternalSEW.g:1180:2: ( RULE_STRING ) |
| { |
| // InternalSEW.g:1180:2: ( RULE_STRING ) |
| // InternalSEW.g:1181:3: RULE_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall()); |
| } |
| match(input,RULE_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEStringAccess().getSTRINGTerminalRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEString" |
| |
| |
| // $ANTLR start "entryRuleDeprecatedReservedWord" |
| // InternalSEW.g:1191:1: entryRuleDeprecatedReservedWord : ruleDeprecatedReservedWord EOF ; |
| public final void entryRuleDeprecatedReservedWord() throws RecognitionException { |
| try { |
| // InternalSEW.g:1192:1: ( ruleDeprecatedReservedWord EOF ) |
| // InternalSEW.g:1193:1: ruleDeprecatedReservedWord EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedReservedWordRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleDeprecatedReservedWord(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedReservedWordRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleDeprecatedReservedWord" |
| |
| |
| // $ANTLR start "ruleDeprecatedReservedWord" |
| // InternalSEW.g:1200:1: ruleDeprecatedReservedWord : ( ( rule__DeprecatedReservedWord__Alternatives ) ) ; |
| public final void ruleDeprecatedReservedWord() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1204:2: ( ( ( rule__DeprecatedReservedWord__Alternatives ) ) ) |
| // InternalSEW.g:1205:2: ( ( rule__DeprecatedReservedWord__Alternatives ) ) |
| { |
| // InternalSEW.g:1205:2: ( ( rule__DeprecatedReservedWord__Alternatives ) ) |
| // InternalSEW.g:1206:3: ( rule__DeprecatedReservedWord__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedReservedWordAccess().getAlternatives()); |
| } |
| // InternalSEW.g:1207:3: ( rule__DeprecatedReservedWord__Alternatives ) |
| // InternalSEW.g:1207:4: rule__DeprecatedReservedWord__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedReservedWord__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedReservedWordAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleDeprecatedReservedWord" |
| |
| |
| // $ANTLR start "entryRuleDeprecatedObject" |
| // InternalSEW.g:1216:1: entryRuleDeprecatedObject : ruleDeprecatedObject EOF ; |
| public final void entryRuleDeprecatedObject() throws RecognitionException { |
| try { |
| // InternalSEW.g:1217:1: ( ruleDeprecatedObject EOF ) |
| // InternalSEW.g:1218:1: ruleDeprecatedObject EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleDeprecatedObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleDeprecatedObject" |
| |
| |
| // $ANTLR start "ruleDeprecatedObject" |
| // InternalSEW.g:1225:1: ruleDeprecatedObject : ( ( rule__DeprecatedObject__Alternatives ) ) ; |
| public final void ruleDeprecatedObject() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1229:2: ( ( ( rule__DeprecatedObject__Alternatives ) ) ) |
| // InternalSEW.g:1230:2: ( ( rule__DeprecatedObject__Alternatives ) ) |
| { |
| // InternalSEW.g:1230:2: ( ( rule__DeprecatedObject__Alternatives ) ) |
| // InternalSEW.g:1231:3: ( rule__DeprecatedObject__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getAlternatives()); |
| } |
| // InternalSEW.g:1232:3: ( rule__DeprecatedObject__Alternatives ) |
| // InternalSEW.g:1232:4: rule__DeprecatedObject__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleDeprecatedObject" |
| |
| |
| // $ANTLR start "entryRuleDeprecatedProperty" |
| // InternalSEW.g:1241:1: entryRuleDeprecatedProperty : ruleDeprecatedProperty EOF ; |
| public final void entryRuleDeprecatedProperty() throws RecognitionException { |
| try { |
| // InternalSEW.g:1242:1: ( ruleDeprecatedProperty EOF ) |
| // InternalSEW.g:1243:1: ruleDeprecatedProperty EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedPropertyRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleDeprecatedProperty(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedPropertyRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleDeprecatedProperty" |
| |
| |
| // $ANTLR start "ruleDeprecatedProperty" |
| // InternalSEW.g:1250:1: ruleDeprecatedProperty : ( ( rule__DeprecatedProperty__Alternatives ) ) ; |
| public final void ruleDeprecatedProperty() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1254:2: ( ( ( rule__DeprecatedProperty__Alternatives ) ) ) |
| // InternalSEW.g:1255:2: ( ( rule__DeprecatedProperty__Alternatives ) ) |
| { |
| // InternalSEW.g:1255:2: ( ( rule__DeprecatedProperty__Alternatives ) ) |
| // InternalSEW.g:1256:3: ( rule__DeprecatedProperty__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedPropertyAccess().getAlternatives()); |
| } |
| // InternalSEW.g:1257:3: ( rule__DeprecatedProperty__Alternatives ) |
| // InternalSEW.g:1257:4: rule__DeprecatedProperty__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedProperty__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedPropertyAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleDeprecatedProperty" |
| |
| |
| // $ANTLR start "entryRuleDeprecatedSection" |
| // InternalSEW.g:1266:1: entryRuleDeprecatedSection : ruleDeprecatedSection EOF ; |
| public final void entryRuleDeprecatedSection() throws RecognitionException { |
| try { |
| // InternalSEW.g:1267:1: ( ruleDeprecatedSection EOF ) |
| // InternalSEW.g:1268:1: ruleDeprecatedSection EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleDeprecatedSection(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleDeprecatedSection" |
| |
| |
| // $ANTLR start "ruleDeprecatedSection" |
| // InternalSEW.g:1275:1: ruleDeprecatedSection : ( ( rule__DeprecatedSection__Alternatives ) ) ; |
| public final void ruleDeprecatedSection() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1279:2: ( ( ( rule__DeprecatedSection__Alternatives ) ) ) |
| // InternalSEW.g:1280:2: ( ( rule__DeprecatedSection__Alternatives ) ) |
| { |
| // InternalSEW.g:1280:2: ( ( rule__DeprecatedSection__Alternatives ) ) |
| // InternalSEW.g:1281:3: ( rule__DeprecatedSection__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getAlternatives()); |
| } |
| // InternalSEW.g:1282:3: ( rule__DeprecatedSection__Alternatives ) |
| // InternalSEW.g:1282:4: rule__DeprecatedSection__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleDeprecatedSection" |
| |
| |
| // $ANTLR start "entryRuleDeprecatedAttribute" |
| // InternalSEW.g:1291:1: entryRuleDeprecatedAttribute : ruleDeprecatedAttribute EOF ; |
| public final void entryRuleDeprecatedAttribute() throws RecognitionException { |
| try { |
| // InternalSEW.g:1292:1: ( ruleDeprecatedAttribute EOF ) |
| // InternalSEW.g:1293:1: ruleDeprecatedAttribute EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleDeprecatedAttribute(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleDeprecatedAttribute" |
| |
| |
| // $ANTLR start "ruleDeprecatedAttribute" |
| // InternalSEW.g:1300:1: ruleDeprecatedAttribute : ( ( rule__DeprecatedAttribute__Group__0 ) ) ; |
| public final void ruleDeprecatedAttribute() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1304:2: ( ( ( rule__DeprecatedAttribute__Group__0 ) ) ) |
| // InternalSEW.g:1305:2: ( ( rule__DeprecatedAttribute__Group__0 ) ) |
| { |
| // InternalSEW.g:1305:2: ( ( rule__DeprecatedAttribute__Group__0 ) ) |
| // InternalSEW.g:1306:3: ( rule__DeprecatedAttribute__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeAccess().getGroup()); |
| } |
| // InternalSEW.g:1307:3: ( rule__DeprecatedAttribute__Group__0 ) |
| // InternalSEW.g:1307:4: rule__DeprecatedAttribute__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedAttribute__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleDeprecatedAttribute" |
| |
| |
| // $ANTLR start "entryRuleDeprecatedAttributeID" |
| // InternalSEW.g:1316:1: entryRuleDeprecatedAttributeID : ruleDeprecatedAttributeID EOF ; |
| public final void entryRuleDeprecatedAttributeID() throws RecognitionException { |
| try { |
| // InternalSEW.g:1317:1: ( ruleDeprecatedAttributeID EOF ) |
| // InternalSEW.g:1318:1: ruleDeprecatedAttributeID EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeIDRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleDeprecatedAttributeID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeIDRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleDeprecatedAttributeID" |
| |
| |
| // $ANTLR start "ruleDeprecatedAttributeID" |
| // InternalSEW.g:1325:1: ruleDeprecatedAttributeID : ( ( rule__DeprecatedAttributeID__Alternatives ) ) ; |
| public final void ruleDeprecatedAttributeID() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1329:2: ( ( ( rule__DeprecatedAttributeID__Alternatives ) ) ) |
| // InternalSEW.g:1330:2: ( ( rule__DeprecatedAttributeID__Alternatives ) ) |
| { |
| // InternalSEW.g:1330:2: ( ( rule__DeprecatedAttributeID__Alternatives ) ) |
| // InternalSEW.g:1331:3: ( rule__DeprecatedAttributeID__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeIDAccess().getAlternatives()); |
| } |
| // InternalSEW.g:1332:3: ( rule__DeprecatedAttributeID__Alternatives ) |
| // InternalSEW.g:1332:4: rule__DeprecatedAttributeID__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedAttributeID__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeIDAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleDeprecatedAttributeID" |
| |
| |
| // $ANTLR start "entryRuleDeprecatedExpression" |
| // InternalSEW.g:1341:1: entryRuleDeprecatedExpression : ruleDeprecatedExpression EOF ; |
| public final void entryRuleDeprecatedExpression() throws RecognitionException { |
| try { |
| // InternalSEW.g:1342:1: ( ruleDeprecatedExpression EOF ) |
| // InternalSEW.g:1343:1: ruleDeprecatedExpression EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedExpressionRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleDeprecatedExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedExpressionRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleDeprecatedExpression" |
| |
| |
| // $ANTLR start "ruleDeprecatedExpression" |
| // InternalSEW.g:1350:1: ruleDeprecatedExpression : ( ( rule__DeprecatedExpression__Group__0 ) ) ; |
| public final void ruleDeprecatedExpression() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1354:2: ( ( ( rule__DeprecatedExpression__Group__0 ) ) ) |
| // InternalSEW.g:1355:2: ( ( rule__DeprecatedExpression__Group__0 ) ) |
| { |
| // InternalSEW.g:1355:2: ( ( rule__DeprecatedExpression__Group__0 ) ) |
| // InternalSEW.g:1356:3: ( rule__DeprecatedExpression__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedExpressionAccess().getGroup()); |
| } |
| // InternalSEW.g:1357:3: ( rule__DeprecatedExpression__Group__0 ) |
| // InternalSEW.g:1357:4: rule__DeprecatedExpression__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedExpression__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedExpressionAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleDeprecatedExpression" |
| |
| |
| // $ANTLR start "rule__Workflow__Alternatives_2" |
| // InternalSEW.g:1365:1: rule__Workflow__Alternatives_2 : ( ( ( rule__Workflow__Group_2_0__0 ) ) | ( ( rule__Workflow__ElementAssignment_2_1 )* ) | ( ( rule__Workflow__ElementAssignment_2_2 ) ) ); |
| public final void rule__Workflow__Alternatives_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1369:1: ( ( ( rule__Workflow__Group_2_0__0 ) ) | ( ( rule__Workflow__ElementAssignment_2_1 )* ) | ( ( rule__Workflow__ElementAssignment_2_2 ) ) ) |
| int alt2=3; |
| alt2 = dfa2.predict(input); |
| switch (alt2) { |
| case 1 : |
| // InternalSEW.g:1370:2: ( ( rule__Workflow__Group_2_0__0 ) ) |
| { |
| // InternalSEW.g:1370:2: ( ( rule__Workflow__Group_2_0__0 ) ) |
| // InternalSEW.g:1371:3: ( rule__Workflow__Group_2_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getGroup_2_0()); |
| } |
| // InternalSEW.g:1372:3: ( rule__Workflow__Group_2_0__0 ) |
| // InternalSEW.g:1372:4: rule__Workflow__Group_2_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group_2_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getGroup_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1376:2: ( ( rule__Workflow__ElementAssignment_2_1 )* ) |
| { |
| // InternalSEW.g:1376:2: ( ( rule__Workflow__ElementAssignment_2_1 )* ) |
| // InternalSEW.g:1377:3: ( rule__Workflow__ElementAssignment_2_1 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getElementAssignment_2_1()); |
| } |
| // InternalSEW.g:1378:3: ( rule__Workflow__ElementAssignment_2_1 )* |
| loop1: |
| do { |
| int alt1=2; |
| int LA1_0 = input.LA(1); |
| |
| if ( (LA1_0==RULE_XIDENDIFIER||LA1_0==14||LA1_0==18||(LA1_0>=42 && LA1_0<=47)) ) { |
| alt1=1; |
| } |
| |
| |
| switch (alt1) { |
| case 1 : |
| // InternalSEW.g:1378:4: rule__Workflow__ElementAssignment_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_3); |
| rule__Workflow__ElementAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop1; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getElementAssignment_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:1382:2: ( ( rule__Workflow__ElementAssignment_2_2 ) ) |
| { |
| // InternalSEW.g:1382:2: ( ( rule__Workflow__ElementAssignment_2_2 ) ) |
| // InternalSEW.g:1383:3: ( rule__Workflow__ElementAssignment_2_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getElementAssignment_2_2()); |
| } |
| // InternalSEW.g:1384:3: ( rule__Workflow__ElementAssignment_2_2 ) |
| // InternalSEW.g:1384:4: rule__Workflow__ElementAssignment_2_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__ElementAssignment_2_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getElementAssignment_2_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Alternatives_2" |
| |
| |
| // $ANTLR start "rule__Workflow__TypeAlternatives_2_0_0_0" |
| // InternalSEW.g:1392:1: rule__Workflow__TypeAlternatives_2_0_0_0 : ( ( 'workflow' ) | ( 'symbex-workflow' ) ); |
| public final void rule__Workflow__TypeAlternatives_2_0_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1396:1: ( ( 'workflow' ) | ( 'symbex-workflow' ) ) |
| int alt3=2; |
| int LA3_0 = input.LA(1); |
| |
| if ( (LA3_0==14) ) { |
| alt3=1; |
| } |
| else if ( (LA3_0==15) ) { |
| alt3=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 3, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt3) { |
| case 1 : |
| // InternalSEW.g:1397:2: ( 'workflow' ) |
| { |
| // InternalSEW.g:1397:2: ( 'workflow' ) |
| // InternalSEW.g:1398:3: 'workflow' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getTypeWorkflowKeyword_2_0_0_0_0()); |
| } |
| match(input,14,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getTypeWorkflowKeyword_2_0_0_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1403:2: ( 'symbex-workflow' ) |
| { |
| // InternalSEW.g:1403:2: ( 'symbex-workflow' ) |
| // InternalSEW.g:1404:3: 'symbex-workflow' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getTypeSymbexWorkflowKeyword_2_0_0_0_1()); |
| } |
| match(input,15,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getTypeSymbexWorkflowKeyword_2_0_0_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__TypeAlternatives_2_0_0_0" |
| |
| |
| // $ANTLR start "rule__Workflow__ElementAlternatives_2_0_4_0" |
| // InternalSEW.g:1413:1: rule__Workflow__ElementAlternatives_2_0_4_0 : ( ( ruleObject ) | ( ruleProperty ) ); |
| public final void rule__Workflow__ElementAlternatives_2_0_4_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1417:1: ( ( ruleObject ) | ( ruleProperty ) ) |
| int alt4=2; |
| alt4 = dfa4.predict(input); |
| switch (alt4) { |
| case 1 : |
| // InternalSEW.g:1418:2: ( ruleObject ) |
| { |
| // InternalSEW.g:1418:2: ( ruleObject ) |
| // InternalSEW.g:1419:3: ruleObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getElementObjectParserRuleCall_2_0_4_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getElementObjectParserRuleCall_2_0_4_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1424:2: ( ruleProperty ) |
| { |
| // InternalSEW.g:1424:2: ( ruleProperty ) |
| // InternalSEW.g:1425:3: ruleProperty |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getElementPropertyParserRuleCall_2_0_4_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleProperty(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getElementPropertyParserRuleCall_2_0_4_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__ElementAlternatives_2_0_4_0" |
| |
| |
| // $ANTLR start "rule__Workflow__ElementAlternatives_2_1_0" |
| // InternalSEW.g:1434:1: rule__Workflow__ElementAlternatives_2_1_0 : ( ( ruleObject ) | ( ruleProperty ) ); |
| public final void rule__Workflow__ElementAlternatives_2_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1438:1: ( ( ruleObject ) | ( ruleProperty ) ) |
| int alt5=2; |
| alt5 = dfa5.predict(input); |
| switch (alt5) { |
| case 1 : |
| // InternalSEW.g:1439:2: ( ruleObject ) |
| { |
| // InternalSEW.g:1439:2: ( ruleObject ) |
| // InternalSEW.g:1440:3: ruleObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getElementObjectParserRuleCall_2_1_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getElementObjectParserRuleCall_2_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1445:2: ( ruleProperty ) |
| { |
| // InternalSEW.g:1445:2: ( ruleProperty ) |
| // InternalSEW.g:1446:3: ruleProperty |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getElementPropertyParserRuleCall_2_1_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleProperty(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getElementPropertyParserRuleCall_2_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__ElementAlternatives_2_1_0" |
| |
| |
| // $ANTLR start "rule__Prolog__Alternatives_0" |
| // InternalSEW.g:1455:1: rule__Prolog__Alternatives_0 : ( ( '@sew' ) | ( '@favm' ) ); |
| public final void rule__Prolog__Alternatives_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1459:1: ( ( '@sew' ) | ( '@favm' ) ) |
| int alt6=2; |
| int LA6_0 = input.LA(1); |
| |
| if ( (LA6_0==16) ) { |
| alt6=1; |
| } |
| else if ( (LA6_0==17) ) { |
| alt6=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 6, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt6) { |
| case 1 : |
| // InternalSEW.g:1460:2: ( '@sew' ) |
| { |
| // InternalSEW.g:1460:2: ( '@sew' ) |
| // InternalSEW.g:1461:3: '@sew' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getSewKeyword_0_0()); |
| } |
| match(input,16,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getSewKeyword_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1466:2: ( '@favm' ) |
| { |
| // InternalSEW.g:1466:2: ( '@favm' ) |
| // InternalSEW.g:1467:3: '@favm' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getFavmKeyword_0_1()); |
| } |
| match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getFavmKeyword_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Alternatives_0" |
| |
| |
| // $ANTLR start "rule__Prolog__Alternatives_2" |
| // InternalSEW.g:1476:1: rule__Prolog__Alternatives_2 : ( ( 'workflow' ) | ( 'sew' ) ); |
| public final void rule__Prolog__Alternatives_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1480:1: ( ( 'workflow' ) | ( 'sew' ) ) |
| int alt7=2; |
| int LA7_0 = input.LA(1); |
| |
| if ( (LA7_0==14) ) { |
| alt7=1; |
| } |
| else if ( (LA7_0==18) ) { |
| alt7=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 7, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt7) { |
| case 1 : |
| // InternalSEW.g:1481:2: ( 'workflow' ) |
| { |
| // InternalSEW.g:1481:2: ( 'workflow' ) |
| // InternalSEW.g:1482:3: 'workflow' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getWorkflowKeyword_2_0()); |
| } |
| match(input,14,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getWorkflowKeyword_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1487:2: ( 'sew' ) |
| { |
| // InternalSEW.g:1487:2: ( 'sew' ) |
| // InternalSEW.g:1488:3: 'sew' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getSewKeyword_2_1()); |
| } |
| match(input,18,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getSewKeyword_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Alternatives_2" |
| |
| |
| // $ANTLR start "rule__Prolog__Alternatives_3" |
| // InternalSEW.g:1497:1: rule__Prolog__Alternatives_3 : ( ( ( rule__Prolog__Group_3_0__0 ) ) | ( ruleUFI ) | ( ruleEString ) ); |
| public final void rule__Prolog__Alternatives_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1501:1: ( ( ( rule__Prolog__Group_3_0__0 ) ) | ( ruleUFI ) | ( ruleEString ) ) |
| int alt8=3; |
| switch ( input.LA(1) ) { |
| case 53: |
| { |
| alt8=1; |
| } |
| break; |
| case RULE_XIDENDIFIER: |
| case 14: |
| case 18: |
| case 42: |
| case 43: |
| case 44: |
| case 45: |
| case 46: |
| case 47: |
| { |
| alt8=2; |
| } |
| break; |
| case RULE_STRING: |
| { |
| alt8=3; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 8, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt8) { |
| case 1 : |
| // InternalSEW.g:1502:2: ( ( rule__Prolog__Group_3_0__0 ) ) |
| { |
| // InternalSEW.g:1502:2: ( ( rule__Prolog__Group_3_0__0 ) ) |
| // InternalSEW.g:1503:3: ( rule__Prolog__Group_3_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getGroup_3_0()); |
| } |
| // InternalSEW.g:1504:3: ( rule__Prolog__Group_3_0__0 ) |
| // InternalSEW.g:1504:4: rule__Prolog__Group_3_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Group_3_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getGroup_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1508:2: ( ruleUFI ) |
| { |
| // InternalSEW.g:1508:2: ( ruleUFI ) |
| // InternalSEW.g:1509:3: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getUFIParserRuleCall_3_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getUFIParserRuleCall_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:1514:2: ( ruleEString ) |
| { |
| // InternalSEW.g:1514:2: ( ruleEString ) |
| // InternalSEW.g:1515:3: ruleEString |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getEStringParserRuleCall_3_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEString(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getEStringParserRuleCall_3_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Alternatives_3" |
| |
| |
| // $ANTLR start "rule__ReservedWord__Alternatives" |
| // InternalSEW.g:1524:1: rule__ReservedWord__Alternatives : ( ( 'workflow' ) | ( 'sew' ) | ( ruleDeprecatedReservedWord ) ); |
| public final void rule__ReservedWord__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1528:1: ( ( 'workflow' ) | ( 'sew' ) | ( ruleDeprecatedReservedWord ) ) |
| int alt9=3; |
| switch ( input.LA(1) ) { |
| case 14: |
| { |
| alt9=1; |
| } |
| break; |
| case 18: |
| { |
| alt9=2; |
| } |
| break; |
| case 42: |
| case 43: |
| case 44: |
| case 45: |
| case 46: |
| case 47: |
| { |
| alt9=3; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 9, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt9) { |
| case 1 : |
| // InternalSEW.g:1529:2: ( 'workflow' ) |
| { |
| // InternalSEW.g:1529:2: ( 'workflow' ) |
| // InternalSEW.g:1530:3: 'workflow' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getReservedWordAccess().getWorkflowKeyword_0()); |
| } |
| match(input,14,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getReservedWordAccess().getWorkflowKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1535:2: ( 'sew' ) |
| { |
| // InternalSEW.g:1535:2: ( 'sew' ) |
| // InternalSEW.g:1536:3: 'sew' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getReservedWordAccess().getSewKeyword_1()); |
| } |
| match(input,18,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getReservedWordAccess().getSewKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:1541:2: ( ruleDeprecatedReservedWord ) |
| { |
| // InternalSEW.g:1541:2: ( ruleDeprecatedReservedWord ) |
| // InternalSEW.g:1542:3: ruleDeprecatedReservedWord |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getReservedWordAccess().getDeprecatedReservedWordParserRuleCall_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedReservedWord(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getReservedWordAccess().getDeprecatedReservedWordParserRuleCall_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ReservedWord__Alternatives" |
| |
| |
| // $ANTLR start "rule__XID__Alternatives" |
| // InternalSEW.g:1551:1: rule__XID__Alternatives : ( ( ruleReservedWord ) | ( RULE_XIDENDIFIER ) ); |
| public final void rule__XID__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1555:1: ( ( ruleReservedWord ) | ( RULE_XIDENDIFIER ) ) |
| int alt10=2; |
| int LA10_0 = input.LA(1); |
| |
| if ( (LA10_0==14||LA10_0==18||(LA10_0>=42 && LA10_0<=47)) ) { |
| alt10=1; |
| } |
| else if ( (LA10_0==RULE_XIDENDIFIER) ) { |
| alt10=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 10, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt10) { |
| case 1 : |
| // InternalSEW.g:1556:2: ( ruleReservedWord ) |
| { |
| // InternalSEW.g:1556:2: ( ruleReservedWord ) |
| // InternalSEW.g:1557:3: ruleReservedWord |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXIDAccess().getReservedWordParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleReservedWord(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXIDAccess().getReservedWordParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1562:2: ( RULE_XIDENDIFIER ) |
| { |
| // InternalSEW.g:1562:2: ( RULE_XIDENDIFIER ) |
| // InternalSEW.g:1563:3: RULE_XIDENDIFIER |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXIDAccess().getXIDENDIFIERTerminalRuleCall_1()); |
| } |
| match(input,RULE_XIDENDIFIER,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXIDAccess().getXIDENDIFIERTerminalRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XID__Alternatives" |
| |
| |
| // $ANTLR start "rule__UFI__Alternatives_1_0" |
| // InternalSEW.g:1572:1: rule__UFI__Alternatives_1_0 : ( ( '::' ) | ( '.' ) ); |
| public final void rule__UFI__Alternatives_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1576:1: ( ( '::' ) | ( '.' ) ) |
| int alt11=2; |
| int LA11_0 = input.LA(1); |
| |
| if ( (LA11_0==19) ) { |
| alt11=1; |
| } |
| else if ( (LA11_0==20) ) { |
| alt11=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 11, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt11) { |
| case 1 : |
| // InternalSEW.g:1577:2: ( '::' ) |
| { |
| // InternalSEW.g:1577:2: ( '::' ) |
| // InternalSEW.g:1578:3: '::' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUFIAccess().getColonColonKeyword_1_0_0()); |
| } |
| match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUFIAccess().getColonColonKeyword_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1583:2: ( '.' ) |
| { |
| // InternalSEW.g:1583:2: ( '.' ) |
| // InternalSEW.g:1584:3: '.' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUFIAccess().getFullStopKeyword_1_0_1()); |
| } |
| match(input,20,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUFIAccess().getFullStopKeyword_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UFI__Alternatives_1_0" |
| |
| |
| // $ANTLR start "rule__Object__Alternatives" |
| // InternalSEW.g:1593:1: rule__Object__Alternatives : ( ( ( rule__Object__Group_0__0 ) ) | ( ( rule__Object__Group_1__0 ) ) ); |
| public final void rule__Object__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1597:1: ( ( ( rule__Object__Group_0__0 ) ) | ( ( rule__Object__Group_1__0 ) ) ) |
| int alt12=2; |
| alt12 = dfa12.predict(input); |
| switch (alt12) { |
| case 1 : |
| // InternalSEW.g:1598:2: ( ( rule__Object__Group_0__0 ) ) |
| { |
| // InternalSEW.g:1598:2: ( ( rule__Object__Group_0__0 ) ) |
| // InternalSEW.g:1599:3: ( rule__Object__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getGroup_0()); |
| } |
| // InternalSEW.g:1600:3: ( rule__Object__Group_0__0 ) |
| // InternalSEW.g:1600:4: rule__Object__Group_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1604:2: ( ( rule__Object__Group_1__0 ) ) |
| { |
| // InternalSEW.g:1604:2: ( ( rule__Object__Group_1__0 ) ) |
| // InternalSEW.g:1605:3: ( rule__Object__Group_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getGroup_1()); |
| } |
| // InternalSEW.g:1606:3: ( rule__Object__Group_1__0 ) |
| // InternalSEW.g:1606:4: rule__Object__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Alternatives" |
| |
| |
| // $ANTLR start "rule__Object__ElementAlternatives_0_5_0" |
| // InternalSEW.g:1614:1: rule__Object__ElementAlternatives_0_5_0 : ( ( ruleObject ) | ( ruleProperty ) ); |
| public final void rule__Object__ElementAlternatives_0_5_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1618:1: ( ( ruleObject ) | ( ruleProperty ) ) |
| int alt13=2; |
| alt13 = dfa13.predict(input); |
| switch (alt13) { |
| case 1 : |
| // InternalSEW.g:1619:2: ( ruleObject ) |
| { |
| // InternalSEW.g:1619:2: ( ruleObject ) |
| // InternalSEW.g:1620:3: ruleObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getElementObjectParserRuleCall_0_5_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getElementObjectParserRuleCall_0_5_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1625:2: ( ruleProperty ) |
| { |
| // InternalSEW.g:1625:2: ( ruleProperty ) |
| // InternalSEW.g:1626:3: ruleProperty |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getElementPropertyParserRuleCall_0_5_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleProperty(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getElementPropertyParserRuleCall_0_5_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__ElementAlternatives_0_5_0" |
| |
| |
| // $ANTLR start "rule__Object__Alternatives_1_2" |
| // InternalSEW.g:1635:1: rule__Object__Alternatives_1_2 : ( ( ':=' ) | ( '+:=' ) ); |
| public final void rule__Object__Alternatives_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1639:1: ( ( ':=' ) | ( '+:=' ) ) |
| int alt14=2; |
| int LA14_0 = input.LA(1); |
| |
| if ( (LA14_0==21) ) { |
| alt14=1; |
| } |
| else if ( (LA14_0==22) ) { |
| alt14=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 14, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt14) { |
| case 1 : |
| // InternalSEW.g:1640:2: ( ':=' ) |
| { |
| // InternalSEW.g:1640:2: ( ':=' ) |
| // InternalSEW.g:1641:3: ':=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getColonEqualsSignKeyword_1_2_0()); |
| } |
| match(input,21,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getColonEqualsSignKeyword_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1646:2: ( '+:=' ) |
| { |
| // InternalSEW.g:1646:2: ( '+:=' ) |
| // InternalSEW.g:1647:3: '+:=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getPlusSignColonEqualsSignKeyword_1_2_1()); |
| } |
| match(input,22,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getPlusSignColonEqualsSignKeyword_1_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Alternatives_1_2" |
| |
| |
| // $ANTLR start "rule__Object__ElementAlternatives_1_5_0" |
| // InternalSEW.g:1656:1: rule__Object__ElementAlternatives_1_5_0 : ( ( ruleObject ) | ( ruleProperty ) ); |
| public final void rule__Object__ElementAlternatives_1_5_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1660:1: ( ( ruleObject ) | ( ruleProperty ) ) |
| int alt15=2; |
| alt15 = dfa15.predict(input); |
| switch (alt15) { |
| case 1 : |
| // InternalSEW.g:1661:2: ( ruleObject ) |
| { |
| // InternalSEW.g:1661:2: ( ruleObject ) |
| // InternalSEW.g:1662:3: ruleObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getElementObjectParserRuleCall_1_5_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getElementObjectParserRuleCall_1_5_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1667:2: ( ruleProperty ) |
| { |
| // InternalSEW.g:1667:2: ( ruleProperty ) |
| // InternalSEW.g:1668:3: ruleProperty |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getElementPropertyParserRuleCall_1_5_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleProperty(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getElementPropertyParserRuleCall_1_5_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__ElementAlternatives_1_5_0" |
| |
| |
| // $ANTLR start "rule__Property__Alternatives" |
| // InternalSEW.g:1677:1: rule__Property__Alternatives : ( ( ruleSection ) | ( ruleAttribute ) ); |
| public final void rule__Property__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1681:1: ( ( ruleSection ) | ( ruleAttribute ) ) |
| int alt16=2; |
| alt16 = dfa16.predict(input); |
| switch (alt16) { |
| case 1 : |
| // InternalSEW.g:1682:2: ( ruleSection ) |
| { |
| // InternalSEW.g:1682:2: ( ruleSection ) |
| // InternalSEW.g:1683:3: ruleSection |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyAccess().getSectionParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleSection(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyAccess().getSectionParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1688:2: ( ruleAttribute ) |
| { |
| // InternalSEW.g:1688:2: ( ruleAttribute ) |
| // InternalSEW.g:1689:3: ruleAttribute |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyAccess().getAttributeParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleAttribute(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyAccess().getAttributeParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Property__Alternatives" |
| |
| |
| // $ANTLR start "rule__Section__Alternatives_2" |
| // InternalSEW.g:1698:1: rule__Section__Alternatives_2 : ( ( ( rule__Section__Group_2_0__0 ) ) | ( ( rule__Section__Group_2_1__0 ) ) ); |
| public final void rule__Section__Alternatives_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1702:1: ( ( ( rule__Section__Group_2_0__0 ) ) | ( ( rule__Section__Group_2_1__0 ) ) ) |
| int alt17=2; |
| int LA17_0 = input.LA(1); |
| |
| if ( (LA17_0==55) ) { |
| alt17=1; |
| } |
| else if ( (LA17_0==57) ) { |
| alt17=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 17, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt17) { |
| case 1 : |
| // InternalSEW.g:1703:2: ( ( rule__Section__Group_2_0__0 ) ) |
| { |
| // InternalSEW.g:1703:2: ( ( rule__Section__Group_2_0__0 ) ) |
| // InternalSEW.g:1704:3: ( rule__Section__Group_2_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getGroup_2_0()); |
| } |
| // InternalSEW.g:1705:3: ( rule__Section__Group_2_0__0 ) |
| // InternalSEW.g:1705:4: rule__Section__Group_2_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Group_2_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getGroup_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1709:2: ( ( rule__Section__Group_2_1__0 ) ) |
| { |
| // InternalSEW.g:1709:2: ( ( rule__Section__Group_2_1__0 ) ) |
| // InternalSEW.g:1710:3: ( rule__Section__Group_2_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getGroup_2_1()); |
| } |
| // InternalSEW.g:1711:3: ( rule__Section__Group_2_1__0 ) |
| // InternalSEW.g:1711:4: rule__Section__Group_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Group_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getGroup_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Alternatives_2" |
| |
| |
| // $ANTLR start "rule__Section__ElementAlternatives_2_0_1_0" |
| // InternalSEW.g:1719:1: rule__Section__ElementAlternatives_2_0_1_0 : ( ( ruleObject ) | ( ruleAttribute ) ); |
| public final void rule__Section__ElementAlternatives_2_0_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1723:1: ( ( ruleObject ) | ( ruleAttribute ) ) |
| int alt18=2; |
| alt18 = dfa18.predict(input); |
| switch (alt18) { |
| case 1 : |
| // InternalSEW.g:1724:2: ( ruleObject ) |
| { |
| // InternalSEW.g:1724:2: ( ruleObject ) |
| // InternalSEW.g:1725:3: ruleObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getElementObjectParserRuleCall_2_0_1_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getElementObjectParserRuleCall_2_0_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1730:2: ( ruleAttribute ) |
| { |
| // InternalSEW.g:1730:2: ( ruleAttribute ) |
| // InternalSEW.g:1731:3: ruleAttribute |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getElementAttributeParserRuleCall_2_0_1_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleAttribute(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getElementAttributeParserRuleCall_2_0_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__ElementAlternatives_2_0_1_0" |
| |
| |
| // $ANTLR start "rule__Section__ElementAlternatives_2_1_1_0" |
| // InternalSEW.g:1740:1: rule__Section__ElementAlternatives_2_1_1_0 : ( ( ruleObject ) | ( ruleAttribute ) ); |
| public final void rule__Section__ElementAlternatives_2_1_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1744:1: ( ( ruleObject ) | ( ruleAttribute ) ) |
| int alt19=2; |
| alt19 = dfa19.predict(input); |
| switch (alt19) { |
| case 1 : |
| // InternalSEW.g:1745:2: ( ruleObject ) |
| { |
| // InternalSEW.g:1745:2: ( ruleObject ) |
| // InternalSEW.g:1746:3: ruleObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getElementObjectParserRuleCall_2_1_1_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getElementObjectParserRuleCall_2_1_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1751:2: ( ruleAttribute ) |
| { |
| // InternalSEW.g:1751:2: ( ruleAttribute ) |
| // InternalSEW.g:1752:3: ruleAttribute |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getElementAttributeParserRuleCall_2_1_1_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleAttribute(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getElementAttributeParserRuleCall_2_1_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__ElementAlternatives_2_1_1_0" |
| |
| |
| // $ANTLR start "rule__Expression__Alternatives" |
| // InternalSEW.g:1761:1: rule__Expression__Alternatives : ( ( ruleconditionalExpression ) | ( ruleDeprecatedExpression ) ); |
| public final void rule__Expression__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1765:1: ( ( ruleconditionalExpression ) | ( ruleDeprecatedExpression ) ) |
| int alt20=2; |
| int LA20_0 = input.LA(1); |
| |
| if ( ((LA20_0>=RULE_CHARACTER && LA20_0<=RULE_XIDENDIFIER)||LA20_0==RULE_INT||LA20_0==14||LA20_0==18||LA20_0==20||(LA20_0>=36 && LA20_0<=47)||LA20_0==55||LA20_0==60||LA20_0==65||(LA20_0>=67 && LA20_0<=69)||(LA20_0>=74 && LA20_0<=80)) ) { |
| alt20=1; |
| } |
| else if ( (LA20_0==72) ) { |
| alt20=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 20, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt20) { |
| case 1 : |
| // InternalSEW.g:1766:2: ( ruleconditionalExpression ) |
| { |
| // InternalSEW.g:1766:2: ( ruleconditionalExpression ) |
| // InternalSEW.g:1767:3: ruleconditionalExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpressionAccess().getConditionalExpressionParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleconditionalExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpressionAccess().getConditionalExpressionParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1772:2: ( ruleDeprecatedExpression ) |
| { |
| // InternalSEW.g:1772:2: ( ruleDeprecatedExpression ) |
| // InternalSEW.g:1773:3: ruleDeprecatedExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpressionAccess().getDeprecatedExpressionParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpressionAccess().getDeprecatedExpressionParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Expression__Alternatives" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__OperatorAlternatives_1_1_0" |
| // InternalSEW.g:1782:1: rule__ConditionalOrExpression__OperatorAlternatives_1_1_0 : ( ( '||' ) | ( 'or' ) ); |
| public final void rule__ConditionalOrExpression__OperatorAlternatives_1_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1786:1: ( ( '||' ) | ( 'or' ) ) |
| int alt21=2; |
| int LA21_0 = input.LA(1); |
| |
| if ( (LA21_0==23) ) { |
| alt21=1; |
| } |
| else if ( (LA21_0==24) ) { |
| alt21=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 21, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt21) { |
| case 1 : |
| // InternalSEW.g:1787:2: ( '||' ) |
| { |
| // InternalSEW.g:1787:2: ( '||' ) |
| // InternalSEW.g:1788:3: '||' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0_0()); |
| } |
| match(input,23,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1793:2: ( 'or' ) |
| { |
| // InternalSEW.g:1793:2: ( 'or' ) |
| // InternalSEW.g:1794:3: 'or' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getOperatorOrKeyword_1_1_0_1()); |
| } |
| match(input,24,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getOperatorOrKeyword_1_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__OperatorAlternatives_1_1_0" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Alternatives_1_3_0" |
| // InternalSEW.g:1803:1: rule__ConditionalOrExpression__Alternatives_1_3_0 : ( ( '||' ) | ( 'or' ) ); |
| public final void rule__ConditionalOrExpression__Alternatives_1_3_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1807:1: ( ( '||' ) | ( 'or' ) ) |
| int alt22=2; |
| int LA22_0 = input.LA(1); |
| |
| if ( (LA22_0==23) ) { |
| alt22=1; |
| } |
| else if ( (LA22_0==24) ) { |
| alt22=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt22) { |
| case 1 : |
| // InternalSEW.g:1808:2: ( '||' ) |
| { |
| // InternalSEW.g:1808:2: ( '||' ) |
| // InternalSEW.g:1809:3: '||' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getVerticalLineVerticalLineKeyword_1_3_0_0()); |
| } |
| match(input,23,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getVerticalLineVerticalLineKeyword_1_3_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1814:2: ( 'or' ) |
| { |
| // InternalSEW.g:1814:2: ( 'or' ) |
| // InternalSEW.g:1815:3: 'or' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getOrKeyword_1_3_0_1()); |
| } |
| match(input,24,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getOrKeyword_1_3_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Alternatives_1_3_0" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__OperatorAlternatives_1_1_0" |
| // InternalSEW.g:1824:1: rule__ConditionalAndExpression__OperatorAlternatives_1_1_0 : ( ( '&&' ) | ( 'and' ) ); |
| public final void rule__ConditionalAndExpression__OperatorAlternatives_1_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1828:1: ( ( '&&' ) | ( 'and' ) ) |
| int alt23=2; |
| int LA23_0 = input.LA(1); |
| |
| if ( (LA23_0==25) ) { |
| alt23=1; |
| } |
| else if ( (LA23_0==26) ) { |
| alt23=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 23, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt23) { |
| case 1 : |
| // InternalSEW.g:1829:2: ( '&&' ) |
| { |
| // InternalSEW.g:1829:2: ( '&&' ) |
| // InternalSEW.g:1830:3: '&&' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0_0()); |
| } |
| match(input,25,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1835:2: ( 'and' ) |
| { |
| // InternalSEW.g:1835:2: ( 'and' ) |
| // InternalSEW.g:1836:3: 'and' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getOperatorAndKeyword_1_1_0_1()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getOperatorAndKeyword_1_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__OperatorAlternatives_1_1_0" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Alternatives_1_3_0" |
| // InternalSEW.g:1845:1: rule__ConditionalAndExpression__Alternatives_1_3_0 : ( ( '&&' ) | ( 'and' ) ); |
| public final void rule__ConditionalAndExpression__Alternatives_1_3_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1849:1: ( ( '&&' ) | ( 'and' ) ) |
| int alt24=2; |
| int LA24_0 = input.LA(1); |
| |
| if ( (LA24_0==25) ) { |
| alt24=1; |
| } |
| else if ( (LA24_0==26) ) { |
| alt24=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 24, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt24) { |
| case 1 : |
| // InternalSEW.g:1850:2: ( '&&' ) |
| { |
| // InternalSEW.g:1850:2: ( '&&' ) |
| // InternalSEW.g:1851:3: '&&' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getAmpersandAmpersandKeyword_1_3_0_0()); |
| } |
| match(input,25,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getAmpersandAmpersandKeyword_1_3_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1856:2: ( 'and' ) |
| { |
| // InternalSEW.g:1856:2: ( 'and' ) |
| // InternalSEW.g:1857:3: 'and' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getAndKeyword_1_3_0_1()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getAndKeyword_1_3_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Alternatives_1_3_0" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__OperatorAlternatives_1_1_0" |
| // InternalSEW.g:1866:1: rule__EqualityExpression__OperatorAlternatives_1_1_0 : ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '=!=' ) | ( '=/=' ) ); |
| public final void rule__EqualityExpression__OperatorAlternatives_1_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1870:1: ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '=!=' ) | ( '=/=' ) ) |
| int alt25=5; |
| switch ( input.LA(1) ) { |
| case 27: |
| { |
| alt25=1; |
| } |
| break; |
| case 28: |
| { |
| alt25=2; |
| } |
| break; |
| case 29: |
| { |
| alt25=3; |
| } |
| break; |
| case 30: |
| { |
| alt25=4; |
| } |
| break; |
| case 31: |
| { |
| alt25=5; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 25, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt25) { |
| case 1 : |
| // InternalSEW.g:1871:2: ( '==' ) |
| { |
| // InternalSEW.g:1871:2: ( '==' ) |
| // InternalSEW.g:1872:3: '==' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); |
| } |
| match(input,27,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1877:2: ( '!=' ) |
| { |
| // InternalSEW.g:1877:2: ( '!=' ) |
| // InternalSEW.g:1878:3: '!=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); |
| } |
| match(input,28,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:1883:2: ( '===' ) |
| { |
| // InternalSEW.g:1883:2: ( '===' ) |
| // InternalSEW.g:1884:3: '===' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getOperatorEqualsSignEqualsSignEqualsSignKeyword_1_1_0_2()); |
| } |
| match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getOperatorEqualsSignEqualsSignEqualsSignKeyword_1_1_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalSEW.g:1889:2: ( '=!=' ) |
| { |
| // InternalSEW.g:1889:2: ( '=!=' ) |
| // InternalSEW.g:1890:3: '=!=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getOperatorEqualsSignExclamationMarkEqualsSignKeyword_1_1_0_3()); |
| } |
| match(input,30,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getOperatorEqualsSignExclamationMarkEqualsSignKeyword_1_1_0_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalSEW.g:1895:2: ( '=/=' ) |
| { |
| // InternalSEW.g:1895:2: ( '=/=' ) |
| // InternalSEW.g:1896:3: '=/=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getOperatorEqualsSignSolidusEqualsSignKeyword_1_1_0_4()); |
| } |
| match(input,31,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getOperatorEqualsSignSolidusEqualsSignKeyword_1_1_0_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__OperatorAlternatives_1_1_0" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__OperatorAlternatives_1_1_0" |
| // InternalSEW.g:1905:1: rule__RelationalExpression__OperatorAlternatives_1_1_0 : ( ( '<' ) | ( '<=' ) | ( '>' ) | ( '>=' ) ); |
| public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1909:1: ( ( '<' ) | ( '<=' ) | ( '>' ) | ( '>=' ) ) |
| int alt26=4; |
| switch ( input.LA(1) ) { |
| case 32: |
| { |
| alt26=1; |
| } |
| break; |
| case 33: |
| { |
| alt26=2; |
| } |
| break; |
| case 34: |
| { |
| alt26=3; |
| } |
| break; |
| case 35: |
| { |
| alt26=4; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 26, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt26) { |
| case 1 : |
| // InternalSEW.g:1910:2: ( '<' ) |
| { |
| // InternalSEW.g:1910:2: ( '<' ) |
| // InternalSEW.g:1911:3: '<' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_0()); |
| } |
| match(input,32,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1916:2: ( '<=' ) |
| { |
| // InternalSEW.g:1916:2: ( '<=' ) |
| // InternalSEW.g:1917:3: '<=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_1()); |
| } |
| match(input,33,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:1922:2: ( '>' ) |
| { |
| // InternalSEW.g:1922:2: ( '>' ) |
| // InternalSEW.g:1923:3: '>' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_2()); |
| } |
| match(input,34,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalSEW.g:1928:2: ( '>=' ) |
| { |
| // InternalSEW.g:1928:2: ( '>=' ) |
| // InternalSEW.g:1929:3: '>=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_3()); |
| } |
| match(input,35,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__OperatorAlternatives_1_1_0" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Alternatives_1" |
| // InternalSEW.g:1938:1: rule__MultiplicativeExpression__Alternatives_1 : ( ( ( rule__MultiplicativeExpression__Group_1_0__0 ) ) | ( ( rule__MultiplicativeExpression__Group_1_1__0 ) ) | ( ( rule__MultiplicativeExpression__Group_1_2__0 ) ) | ( ( rule__MultiplicativeExpression__Group_1_3__0 ) ) ); |
| public final void rule__MultiplicativeExpression__Alternatives_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1942:1: ( ( ( rule__MultiplicativeExpression__Group_1_0__0 ) ) | ( ( rule__MultiplicativeExpression__Group_1_1__0 ) ) | ( ( rule__MultiplicativeExpression__Group_1_2__0 ) ) | ( ( rule__MultiplicativeExpression__Group_1_3__0 ) ) ) |
| int alt27=4; |
| switch ( input.LA(1) ) { |
| case 61: |
| { |
| alt27=1; |
| } |
| break; |
| case 62: |
| { |
| alt27=2; |
| } |
| break; |
| case 63: |
| { |
| alt27=3; |
| } |
| break; |
| case 64: |
| { |
| alt27=4; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 27, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt27) { |
| case 1 : |
| // InternalSEW.g:1943:2: ( ( rule__MultiplicativeExpression__Group_1_0__0 ) ) |
| { |
| // InternalSEW.g:1943:2: ( ( rule__MultiplicativeExpression__Group_1_0__0 ) ) |
| // InternalSEW.g:1944:3: ( rule__MultiplicativeExpression__Group_1_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_0()); |
| } |
| // InternalSEW.g:1945:3: ( rule__MultiplicativeExpression__Group_1_0__0 ) |
| // InternalSEW.g:1945:4: rule__MultiplicativeExpression__Group_1_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1949:2: ( ( rule__MultiplicativeExpression__Group_1_1__0 ) ) |
| { |
| // InternalSEW.g:1949:2: ( ( rule__MultiplicativeExpression__Group_1_1__0 ) ) |
| // InternalSEW.g:1950:3: ( rule__MultiplicativeExpression__Group_1_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_1()); |
| } |
| // InternalSEW.g:1951:3: ( rule__MultiplicativeExpression__Group_1_1__0 ) |
| // InternalSEW.g:1951:4: rule__MultiplicativeExpression__Group_1_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:1955:2: ( ( rule__MultiplicativeExpression__Group_1_2__0 ) ) |
| { |
| // InternalSEW.g:1955:2: ( ( rule__MultiplicativeExpression__Group_1_2__0 ) ) |
| // InternalSEW.g:1956:3: ( rule__MultiplicativeExpression__Group_1_2__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_2()); |
| } |
| // InternalSEW.g:1957:3: ( rule__MultiplicativeExpression__Group_1_2__0 ) |
| // InternalSEW.g:1957:4: rule__MultiplicativeExpression__Group_1_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalSEW.g:1961:2: ( ( rule__MultiplicativeExpression__Group_1_3__0 ) ) |
| { |
| // InternalSEW.g:1961:2: ( ( rule__MultiplicativeExpression__Group_1_3__0 ) ) |
| // InternalSEW.g:1962:3: ( rule__MultiplicativeExpression__Group_1_3__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_3()); |
| } |
| // InternalSEW.g:1963:3: ( rule__MultiplicativeExpression__Group_1_3__0 ) |
| // InternalSEW.g:1963:4: rule__MultiplicativeExpression__Group_1_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Alternatives_1" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Alternatives" |
| // InternalSEW.g:1971:1: rule__PrimaryExpression__Alternatives : ( ( ( rule__PrimaryExpression__Group_0__0 ) ) | ( ( rule__PrimaryExpression__Group_1__0 ) ) | ( ( rule__PrimaryExpression__Group_2__0 ) ) | ( ( rule__PrimaryExpression__Group_3__0 ) ) | ( ruleLiteralExpression ) ); |
| public final void rule__PrimaryExpression__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:1975:1: ( ( ( rule__PrimaryExpression__Group_0__0 ) ) | ( ( rule__PrimaryExpression__Group_1__0 ) ) | ( ( rule__PrimaryExpression__Group_2__0 ) ) | ( ( rule__PrimaryExpression__Group_3__0 ) ) | ( ruleLiteralExpression ) ) |
| int alt28=5; |
| switch ( input.LA(1) ) { |
| case 60: |
| { |
| alt28=1; |
| } |
| break; |
| case 69: |
| { |
| int LA28_2 = input.LA(2); |
| |
| if ( (synpred39_InternalSEW()) ) { |
| alt28=2; |
| } |
| else if ( (true) ) { |
| alt28=5; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 28, 2, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 36: |
| case 37: |
| { |
| alt28=3; |
| } |
| break; |
| case 65: |
| { |
| alt28=4; |
| } |
| break; |
| case RULE_CHARACTER: |
| case RULE_STRING: |
| case RULE_XIDENDIFIER: |
| case RULE_INT: |
| case 14: |
| case 18: |
| case 20: |
| case 38: |
| case 39: |
| case 40: |
| case 41: |
| case 42: |
| case 43: |
| case 44: |
| case 45: |
| case 46: |
| case 47: |
| case 55: |
| case 67: |
| case 68: |
| case 74: |
| case 75: |
| case 76: |
| case 77: |
| case 78: |
| case 79: |
| case 80: |
| { |
| alt28=5; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 28, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt28) { |
| case 1 : |
| // InternalSEW.g:1976:2: ( ( rule__PrimaryExpression__Group_0__0 ) ) |
| { |
| // InternalSEW.g:1976:2: ( ( rule__PrimaryExpression__Group_0__0 ) ) |
| // InternalSEW.g:1977:3: ( rule__PrimaryExpression__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getGroup_0()); |
| } |
| // InternalSEW.g:1978:3: ( rule__PrimaryExpression__Group_0__0 ) |
| // InternalSEW.g:1978:4: rule__PrimaryExpression__Group_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:1982:2: ( ( rule__PrimaryExpression__Group_1__0 ) ) |
| { |
| // InternalSEW.g:1982:2: ( ( rule__PrimaryExpression__Group_1__0 ) ) |
| // InternalSEW.g:1983:3: ( rule__PrimaryExpression__Group_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getGroup_1()); |
| } |
| // InternalSEW.g:1984:3: ( rule__PrimaryExpression__Group_1__0 ) |
| // InternalSEW.g:1984:4: rule__PrimaryExpression__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:1988:2: ( ( rule__PrimaryExpression__Group_2__0 ) ) |
| { |
| // InternalSEW.g:1988:2: ( ( rule__PrimaryExpression__Group_2__0 ) ) |
| // InternalSEW.g:1989:3: ( rule__PrimaryExpression__Group_2__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getGroup_2()); |
| } |
| // InternalSEW.g:1990:3: ( rule__PrimaryExpression__Group_2__0 ) |
| // InternalSEW.g:1990:4: rule__PrimaryExpression__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalSEW.g:1994:2: ( ( rule__PrimaryExpression__Group_3__0 ) ) |
| { |
| // InternalSEW.g:1994:2: ( ( rule__PrimaryExpression__Group_3__0 ) ) |
| // InternalSEW.g:1995:3: ( rule__PrimaryExpression__Group_3__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getGroup_3()); |
| } |
| // InternalSEW.g:1996:3: ( rule__PrimaryExpression__Group_3__0 ) |
| // InternalSEW.g:1996:4: rule__PrimaryExpression__Group_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getGroup_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalSEW.g:2000:2: ( ruleLiteralExpression ) |
| { |
| // InternalSEW.g:2000:2: ( ruleLiteralExpression ) |
| // InternalSEW.g:2001:3: ruleLiteralExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getLiteralExpressionParserRuleCall_4()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getLiteralExpressionParserRuleCall_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Alternatives" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__OperatorAlternatives_2_1_0_0" |
| // InternalSEW.g:2010:1: rule__PrimaryExpression__OperatorAlternatives_2_1_0_0 : ( ( '!' ) | ( 'not' ) ); |
| public final void rule__PrimaryExpression__OperatorAlternatives_2_1_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2014:1: ( ( '!' ) | ( 'not' ) ) |
| int alt29=2; |
| int LA29_0 = input.LA(1); |
| |
| if ( (LA29_0==36) ) { |
| alt29=1; |
| } |
| else if ( (LA29_0==37) ) { |
| alt29=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 29, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt29) { |
| case 1 : |
| // InternalSEW.g:2015:2: ( '!' ) |
| { |
| // InternalSEW.g:2015:2: ( '!' ) |
| // InternalSEW.g:2016:3: '!' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getOperatorExclamationMarkKeyword_2_1_0_0_0()); |
| } |
| match(input,36,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getOperatorExclamationMarkKeyword_2_1_0_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2021:2: ( 'not' ) |
| { |
| // InternalSEW.g:2021:2: ( 'not' ) |
| // InternalSEW.g:2022:3: 'not' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getOperatorNotKeyword_2_1_0_0_1()); |
| } |
| match(input,37,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getOperatorNotKeyword_2_1_0_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__OperatorAlternatives_2_1_0_0" |
| |
| |
| // $ANTLR start "rule__LiteralExpression__Alternatives" |
| // InternalSEW.g:2031:1: rule__LiteralExpression__Alternatives : ( ( ruleLiteralBooleanValue ) | ( ruleLiteralCharacterValue ) | ( ruleLiteralIntegerValue ) | ( ruleLiteralRationalValue ) | ( ruleLiteralFloatValue ) | ( ruleLiteralStringValue ) | ( ruleLiteralNullValue ) | ( ruleLiteralArrayValue ) | ( ruleLiteralObjectReference ) | ( ruleLiteralVariableReference ) | ( ruleLiteralInstanceReference ) ); |
| public final void rule__LiteralExpression__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2035:1: ( ( ruleLiteralBooleanValue ) | ( ruleLiteralCharacterValue ) | ( ruleLiteralIntegerValue ) | ( ruleLiteralRationalValue ) | ( ruleLiteralFloatValue ) | ( ruleLiteralStringValue ) | ( ruleLiteralNullValue ) | ( ruleLiteralArrayValue ) | ( ruleLiteralObjectReference ) | ( ruleLiteralVariableReference ) | ( ruleLiteralInstanceReference ) ) |
| int alt30=11; |
| alt30 = dfa30.predict(input); |
| switch (alt30) { |
| case 1 : |
| // InternalSEW.g:2036:2: ( ruleLiteralBooleanValue ) |
| { |
| // InternalSEW.g:2036:2: ( ruleLiteralBooleanValue ) |
| // InternalSEW.g:2037:3: ruleLiteralBooleanValue |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralBooleanValueParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralBooleanValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getLiteralBooleanValueParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2042:2: ( ruleLiteralCharacterValue ) |
| { |
| // InternalSEW.g:2042:2: ( ruleLiteralCharacterValue ) |
| // InternalSEW.g:2043:3: ruleLiteralCharacterValue |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralCharacterValueParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralCharacterValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getLiteralCharacterValueParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:2048:2: ( ruleLiteralIntegerValue ) |
| { |
| // InternalSEW.g:2048:2: ( ruleLiteralIntegerValue ) |
| // InternalSEW.g:2049:3: ruleLiteralIntegerValue |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralIntegerValueParserRuleCall_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralIntegerValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getLiteralIntegerValueParserRuleCall_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalSEW.g:2054:2: ( ruleLiteralRationalValue ) |
| { |
| // InternalSEW.g:2054:2: ( ruleLiteralRationalValue ) |
| // InternalSEW.g:2055:3: ruleLiteralRationalValue |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralRationalValueParserRuleCall_3()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralRationalValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getLiteralRationalValueParserRuleCall_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalSEW.g:2060:2: ( ruleLiteralFloatValue ) |
| { |
| // InternalSEW.g:2060:2: ( ruleLiteralFloatValue ) |
| // InternalSEW.g:2061:3: ruleLiteralFloatValue |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralFloatValueParserRuleCall_4()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralFloatValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getLiteralFloatValueParserRuleCall_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 6 : |
| // InternalSEW.g:2066:2: ( ruleLiteralStringValue ) |
| { |
| // InternalSEW.g:2066:2: ( ruleLiteralStringValue ) |
| // InternalSEW.g:2067:3: ruleLiteralStringValue |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralStringValueParserRuleCall_5()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralStringValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getLiteralStringValueParserRuleCall_5()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 7 : |
| // InternalSEW.g:2072:2: ( ruleLiteralNullValue ) |
| { |
| // InternalSEW.g:2072:2: ( ruleLiteralNullValue ) |
| // InternalSEW.g:2073:3: ruleLiteralNullValue |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralNullValueParserRuleCall_6()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralNullValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getLiteralNullValueParserRuleCall_6()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 8 : |
| // InternalSEW.g:2078:2: ( ruleLiteralArrayValue ) |
| { |
| // InternalSEW.g:2078:2: ( ruleLiteralArrayValue ) |
| // InternalSEW.g:2079:3: ruleLiteralArrayValue |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralArrayValueParserRuleCall_7()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralArrayValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getLiteralArrayValueParserRuleCall_7()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 9 : |
| // InternalSEW.g:2084:2: ( ruleLiteralObjectReference ) |
| { |
| // InternalSEW.g:2084:2: ( ruleLiteralObjectReference ) |
| // InternalSEW.g:2085:3: ruleLiteralObjectReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralObjectReferenceParserRuleCall_8()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralObjectReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getLiteralObjectReferenceParserRuleCall_8()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 10 : |
| // InternalSEW.g:2090:2: ( ruleLiteralVariableReference ) |
| { |
| // InternalSEW.g:2090:2: ( ruleLiteralVariableReference ) |
| // InternalSEW.g:2091:3: ruleLiteralVariableReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralVariableReferenceParserRuleCall_9()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralVariableReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getLiteralVariableReferenceParserRuleCall_9()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 11 : |
| // InternalSEW.g:2096:2: ( ruleLiteralInstanceReference ) |
| { |
| // InternalSEW.g:2096:2: ( ruleLiteralInstanceReference ) |
| // InternalSEW.g:2097:3: ruleLiteralInstanceReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralInstanceReferenceParserRuleCall_10()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralInstanceReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralExpressionAccess().getLiteralInstanceReferenceParserRuleCall_10()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralExpression__Alternatives" |
| |
| |
| // $ANTLR start "rule__LiteralObjectReference__Alternatives_1" |
| // InternalSEW.g:2106:1: rule__LiteralObjectReference__Alternatives_1 : ( ( ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) ) | ( ( rule__LiteralObjectReference__SymbolAssignment_1_1 ) ) ); |
| public final void rule__LiteralObjectReference__Alternatives_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2110:1: ( ( ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) ) | ( ( rule__LiteralObjectReference__SymbolAssignment_1_1 ) ) ) |
| int alt31=2; |
| alt31 = dfa31.predict(input); |
| switch (alt31) { |
| case 1 : |
| // InternalSEW.g:2111:2: ( ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) ) |
| { |
| // InternalSEW.g:2111:2: ( ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) ) |
| // InternalSEW.g:2112:3: ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralObjectReferenceAccess().getObjectAssignment_1_0()); |
| } |
| // InternalSEW.g:2113:3: ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) |
| // InternalSEW.g:2113:4: rule__LiteralObjectReference__ObjectAssignment_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralObjectReference__ObjectAssignment_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralObjectReferenceAccess().getObjectAssignment_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2117:2: ( ( rule__LiteralObjectReference__SymbolAssignment_1_1 ) ) |
| { |
| // InternalSEW.g:2117:2: ( ( rule__LiteralObjectReference__SymbolAssignment_1_1 ) ) |
| // InternalSEW.g:2118:3: ( rule__LiteralObjectReference__SymbolAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralObjectReferenceAccess().getSymbolAssignment_1_1()); |
| } |
| // InternalSEW.g:2119:3: ( rule__LiteralObjectReference__SymbolAssignment_1_1 ) |
| // InternalSEW.g:2119:4: rule__LiteralObjectReference__SymbolAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralObjectReference__SymbolAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralObjectReferenceAccess().getSymbolAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralObjectReference__Alternatives_1" |
| |
| |
| // $ANTLR start "rule__LiteralVariableReference__Alternatives" |
| // InternalSEW.g:2127:1: rule__LiteralVariableReference__Alternatives : ( ( ruleLiteralTimeVariable ) | ( ruleLiteralTimeDeltaVariable ) ); |
| public final void rule__LiteralVariableReference__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2131:1: ( ( ruleLiteralTimeVariable ) | ( ruleLiteralTimeDeltaVariable ) ) |
| int alt32=2; |
| int LA32_0 = input.LA(1); |
| |
| if ( (LA32_0==74) ) { |
| alt32=1; |
| } |
| else if ( (LA32_0==75) ) { |
| alt32=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 32, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt32) { |
| case 1 : |
| // InternalSEW.g:2132:2: ( ruleLiteralTimeVariable ) |
| { |
| // InternalSEW.g:2132:2: ( ruleLiteralTimeVariable ) |
| // InternalSEW.g:2133:3: ruleLiteralTimeVariable |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralVariableReferenceAccess().getLiteralTimeVariableParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralTimeVariable(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralVariableReferenceAccess().getLiteralTimeVariableParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2138:2: ( ruleLiteralTimeDeltaVariable ) |
| { |
| // InternalSEW.g:2138:2: ( ruleLiteralTimeDeltaVariable ) |
| // InternalSEW.g:2139:3: ruleLiteralTimeDeltaVariable |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralVariableReferenceAccess().getLiteralTimeDeltaVariableParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralTimeDeltaVariable(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralVariableReferenceAccess().getLiteralTimeDeltaVariableParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralVariableReference__Alternatives" |
| |
| |
| // $ANTLR start "rule__LiteralInstanceReference__Alternatives" |
| // InternalSEW.g:2148:1: rule__LiteralInstanceReference__Alternatives : ( ( ruleLiteralThisInstance ) | ( ruleLiteralSelfInstance ) | ( ruleLiteralParentInstance ) | ( ruleLiteralSuperInstance ) | ( ruleLiteralSystemInstance ) | ( ruleLiteralEnvInstance ) ); |
| public final void rule__LiteralInstanceReference__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2152:1: ( ( ruleLiteralThisInstance ) | ( ruleLiteralSelfInstance ) | ( ruleLiteralParentInstance ) | ( ruleLiteralSuperInstance ) | ( ruleLiteralSystemInstance ) | ( ruleLiteralEnvInstance ) ) |
| int alt33=6; |
| switch ( input.LA(1) ) { |
| case 76: |
| { |
| alt33=1; |
| } |
| break; |
| case 77: |
| { |
| alt33=2; |
| } |
| break; |
| case 78: |
| { |
| alt33=3; |
| } |
| break; |
| case 79: |
| { |
| alt33=4; |
| } |
| break; |
| case 80: |
| { |
| alt33=5; |
| } |
| break; |
| case 38: |
| case 39: |
| { |
| alt33=6; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 33, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt33) { |
| case 1 : |
| // InternalSEW.g:2153:2: ( ruleLiteralThisInstance ) |
| { |
| // InternalSEW.g:2153:2: ( ruleLiteralThisInstance ) |
| // InternalSEW.g:2154:3: ruleLiteralThisInstance |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralThisInstanceParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralThisInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralThisInstanceParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2159:2: ( ruleLiteralSelfInstance ) |
| { |
| // InternalSEW.g:2159:2: ( ruleLiteralSelfInstance ) |
| // InternalSEW.g:2160:3: ruleLiteralSelfInstance |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralSelfInstanceParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralSelfInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralSelfInstanceParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:2165:2: ( ruleLiteralParentInstance ) |
| { |
| // InternalSEW.g:2165:2: ( ruleLiteralParentInstance ) |
| // InternalSEW.g:2166:3: ruleLiteralParentInstance |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralParentInstanceParserRuleCall_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralParentInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralParentInstanceParserRuleCall_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalSEW.g:2171:2: ( ruleLiteralSuperInstance ) |
| { |
| // InternalSEW.g:2171:2: ( ruleLiteralSuperInstance ) |
| // InternalSEW.g:2172:3: ruleLiteralSuperInstance |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralSuperInstanceParserRuleCall_3()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralSuperInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralSuperInstanceParserRuleCall_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalSEW.g:2177:2: ( ruleLiteralSystemInstance ) |
| { |
| // InternalSEW.g:2177:2: ( ruleLiteralSystemInstance ) |
| // InternalSEW.g:2178:3: ruleLiteralSystemInstance |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralSystemInstanceParserRuleCall_4()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralSystemInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralSystemInstanceParserRuleCall_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 6 : |
| // InternalSEW.g:2183:2: ( ruleLiteralEnvInstance ) |
| { |
| // InternalSEW.g:2183:2: ( ruleLiteralEnvInstance ) |
| // InternalSEW.g:2184:3: ruleLiteralEnvInstance |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralEnvInstanceParserRuleCall_5()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralEnvInstance(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralInstanceReferenceAccess().getLiteralEnvInstanceParserRuleCall_5()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralInstanceReference__Alternatives" |
| |
| |
| // $ANTLR start "rule__LiteralEnvInstance__SymbolAlternatives_1_0" |
| // InternalSEW.g:2193:1: rule__LiteralEnvInstance__SymbolAlternatives_1_0 : ( ( '$env' ) | ( 'env' ) ); |
| public final void rule__LiteralEnvInstance__SymbolAlternatives_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2197:1: ( ( '$env' ) | ( 'env' ) ) |
| int alt34=2; |
| int LA34_0 = input.LA(1); |
| |
| if ( (LA34_0==38) ) { |
| alt34=1; |
| } |
| else if ( (LA34_0==39) ) { |
| alt34=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 34, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt34) { |
| case 1 : |
| // InternalSEW.g:2198:2: ( '$env' ) |
| { |
| // InternalSEW.g:2198:2: ( '$env' ) |
| // InternalSEW.g:2199:3: '$env' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralEnvInstanceAccess().getSymbolEnvKeyword_1_0_0()); |
| } |
| match(input,38,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralEnvInstanceAccess().getSymbolEnvKeyword_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2204:2: ( 'env' ) |
| { |
| // InternalSEW.g:2204:2: ( 'env' ) |
| // InternalSEW.g:2205:3: 'env' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralEnvInstanceAccess().getSymbolEnvKeyword_1_0_1()); |
| } |
| match(input,39,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralEnvInstanceAccess().getSymbolEnvKeyword_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralEnvInstance__SymbolAlternatives_1_0" |
| |
| |
| // $ANTLR start "rule__EBoolean__Alternatives" |
| // InternalSEW.g:2214:1: rule__EBoolean__Alternatives : ( ( 'true' ) | ( 'false' ) ); |
| public final void rule__EBoolean__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2218:1: ( ( 'true' ) | ( 'false' ) ) |
| int alt35=2; |
| int LA35_0 = input.LA(1); |
| |
| if ( (LA35_0==40) ) { |
| alt35=1; |
| } |
| else if ( (LA35_0==41) ) { |
| alt35=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 35, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt35) { |
| case 1 : |
| // InternalSEW.g:2219:2: ( 'true' ) |
| { |
| // InternalSEW.g:2219:2: ( 'true' ) |
| // InternalSEW.g:2220:3: 'true' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEBooleanAccess().getTrueKeyword_0()); |
| } |
| match(input,40,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEBooleanAccess().getTrueKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2225:2: ( 'false' ) |
| { |
| // InternalSEW.g:2225:2: ( 'false' ) |
| // InternalSEW.g:2226:3: 'false' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEBooleanAccess().getFalseKeyword_1()); |
| } |
| match(input,41,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEBooleanAccess().getFalseKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EBoolean__Alternatives" |
| |
| |
| // $ANTLR start "rule__DeprecatedReservedWord__Alternatives" |
| // InternalSEW.g:2235:1: rule__DeprecatedReservedWord__Alternatives : ( ( 'form' ) | ( 'endform' ) | ( 'prototype' ) | ( 'endprototype' ) | ( 'section' ) | ( 'endsection' ) ); |
| public final void rule__DeprecatedReservedWord__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2239:1: ( ( 'form' ) | ( 'endform' ) | ( 'prototype' ) | ( 'endprototype' ) | ( 'section' ) | ( 'endsection' ) ) |
| int alt36=6; |
| switch ( input.LA(1) ) { |
| case 42: |
| { |
| alt36=1; |
| } |
| break; |
| case 43: |
| { |
| alt36=2; |
| } |
| break; |
| case 44: |
| { |
| alt36=3; |
| } |
| break; |
| case 45: |
| { |
| alt36=4; |
| } |
| break; |
| case 46: |
| { |
| alt36=5; |
| } |
| break; |
| case 47: |
| { |
| alt36=6; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 36, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt36) { |
| case 1 : |
| // InternalSEW.g:2240:2: ( 'form' ) |
| { |
| // InternalSEW.g:2240:2: ( 'form' ) |
| // InternalSEW.g:2241:3: 'form' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedReservedWordAccess().getFormKeyword_0()); |
| } |
| match(input,42,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedReservedWordAccess().getFormKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2246:2: ( 'endform' ) |
| { |
| // InternalSEW.g:2246:2: ( 'endform' ) |
| // InternalSEW.g:2247:3: 'endform' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedReservedWordAccess().getEndformKeyword_1()); |
| } |
| match(input,43,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedReservedWordAccess().getEndformKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:2252:2: ( 'prototype' ) |
| { |
| // InternalSEW.g:2252:2: ( 'prototype' ) |
| // InternalSEW.g:2253:3: 'prototype' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedReservedWordAccess().getPrototypeKeyword_2()); |
| } |
| match(input,44,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedReservedWordAccess().getPrototypeKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalSEW.g:2258:2: ( 'endprototype' ) |
| { |
| // InternalSEW.g:2258:2: ( 'endprototype' ) |
| // InternalSEW.g:2259:3: 'endprototype' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedReservedWordAccess().getEndprototypeKeyword_3()); |
| } |
| match(input,45,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedReservedWordAccess().getEndprototypeKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalSEW.g:2264:2: ( 'section' ) |
| { |
| // InternalSEW.g:2264:2: ( 'section' ) |
| // InternalSEW.g:2265:3: 'section' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedReservedWordAccess().getSectionKeyword_4()); |
| } |
| match(input,46,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedReservedWordAccess().getSectionKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 6 : |
| // InternalSEW.g:2270:2: ( 'endsection' ) |
| { |
| // InternalSEW.g:2270:2: ( 'endsection' ) |
| // InternalSEW.g:2271:3: 'endsection' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedReservedWordAccess().getEndsectionKeyword_5()); |
| } |
| match(input,47,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedReservedWordAccess().getEndsectionKeyword_5()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedReservedWord__Alternatives" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Alternatives" |
| // InternalSEW.g:2280:1: rule__DeprecatedObject__Alternatives : ( ( ( rule__DeprecatedObject__Group_0__0 ) ) | ( ( rule__DeprecatedObject__Group_1__0 ) ) ); |
| public final void rule__DeprecatedObject__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2284:1: ( ( ( rule__DeprecatedObject__Group_0__0 ) ) | ( ( rule__DeprecatedObject__Group_1__0 ) ) ) |
| int alt37=2; |
| int LA37_0 = input.LA(1); |
| |
| if ( (LA37_0==42) ) { |
| alt37=1; |
| } |
| else if ( (LA37_0==44) ) { |
| alt37=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 37, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt37) { |
| case 1 : |
| // InternalSEW.g:2285:2: ( ( rule__DeprecatedObject__Group_0__0 ) ) |
| { |
| // InternalSEW.g:2285:2: ( ( rule__DeprecatedObject__Group_0__0 ) ) |
| // InternalSEW.g:2286:3: ( rule__DeprecatedObject__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getGroup_0()); |
| } |
| // InternalSEW.g:2287:3: ( rule__DeprecatedObject__Group_0__0 ) |
| // InternalSEW.g:2287:4: rule__DeprecatedObject__Group_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2291:2: ( ( rule__DeprecatedObject__Group_1__0 ) ) |
| { |
| // InternalSEW.g:2291:2: ( ( rule__DeprecatedObject__Group_1__0 ) ) |
| // InternalSEW.g:2292:3: ( rule__DeprecatedObject__Group_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getGroup_1()); |
| } |
| // InternalSEW.g:2293:3: ( rule__DeprecatedObject__Group_1__0 ) |
| // InternalSEW.g:2293:4: rule__DeprecatedObject__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Alternatives" |
| |
| |
| // $ANTLR start "rule__DeprecatedProperty__Alternatives" |
| // InternalSEW.g:2301:1: rule__DeprecatedProperty__Alternatives : ( ( ruleDeprecatedSection ) | ( ruleDeprecatedAttribute ) ); |
| public final void rule__DeprecatedProperty__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2305:1: ( ( ruleDeprecatedSection ) | ( ruleDeprecatedAttribute ) ) |
| int alt38=2; |
| alt38 = dfa38.predict(input); |
| switch (alt38) { |
| case 1 : |
| // InternalSEW.g:2306:2: ( ruleDeprecatedSection ) |
| { |
| // InternalSEW.g:2306:2: ( ruleDeprecatedSection ) |
| // InternalSEW.g:2307:3: ruleDeprecatedSection |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedPropertyAccess().getDeprecatedSectionParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedSection(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedPropertyAccess().getDeprecatedSectionParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2312:2: ( ruleDeprecatedAttribute ) |
| { |
| // InternalSEW.g:2312:2: ( ruleDeprecatedAttribute ) |
| // InternalSEW.g:2313:3: ruleDeprecatedAttribute |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedPropertyAccess().getDeprecatedAttributeParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedAttribute(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedPropertyAccess().getDeprecatedAttributeParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedProperty__Alternatives" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Alternatives" |
| // InternalSEW.g:2322:1: rule__DeprecatedSection__Alternatives : ( ( ( rule__DeprecatedSection__Group_0__0 ) ) | ( ( rule__DeprecatedSection__Group_1__0 ) ) ); |
| public final void rule__DeprecatedSection__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2326:1: ( ( ( rule__DeprecatedSection__Group_0__0 ) ) | ( ( rule__DeprecatedSection__Group_1__0 ) ) ) |
| int alt39=2; |
| int LA39_0 = input.LA(1); |
| |
| if ( (LA39_0==46) ) { |
| int LA39_1 = input.LA(2); |
| |
| if ( (LA39_1==RULE_XIDENDIFIER||LA39_1==14||LA39_1==18||(LA39_1>=42 && LA39_1<=47)) ) { |
| alt39=1; |
| } |
| else if ( (LA39_1==RULE_STRING||LA39_1==55||LA39_1==57) ) { |
| alt39=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 39, 1, input); |
| |
| throw nvae; |
| } |
| } |
| else if ( (LA39_0==RULE_XIDENDIFIER||LA39_0==14||LA39_0==18||(LA39_0>=42 && LA39_0<=45)||LA39_0==47) ) { |
| alt39=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 39, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt39) { |
| case 1 : |
| // InternalSEW.g:2327:2: ( ( rule__DeprecatedSection__Group_0__0 ) ) |
| { |
| // InternalSEW.g:2327:2: ( ( rule__DeprecatedSection__Group_0__0 ) ) |
| // InternalSEW.g:2328:3: ( rule__DeprecatedSection__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getGroup_0()); |
| } |
| // InternalSEW.g:2329:3: ( rule__DeprecatedSection__Group_0__0 ) |
| // InternalSEW.g:2329:4: rule__DeprecatedSection__Group_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2333:2: ( ( rule__DeprecatedSection__Group_1__0 ) ) |
| { |
| // InternalSEW.g:2333:2: ( ( rule__DeprecatedSection__Group_1__0 ) ) |
| // InternalSEW.g:2334:3: ( rule__DeprecatedSection__Group_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getGroup_1()); |
| } |
| // InternalSEW.g:2335:3: ( rule__DeprecatedSection__Group_1__0 ) |
| // InternalSEW.g:2335:4: rule__DeprecatedSection__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Alternatives" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__ElementAlternatives_0_3_0" |
| // InternalSEW.g:2343:1: rule__DeprecatedSection__ElementAlternatives_0_3_0 : ( ( ruleDeprecatedAttribute ) | ( ruleDeprecatedObject ) | ( ruleObject ) ); |
| public final void rule__DeprecatedSection__ElementAlternatives_0_3_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2347:1: ( ( ruleDeprecatedAttribute ) | ( ruleDeprecatedObject ) | ( ruleObject ) ) |
| int alt40=3; |
| alt40 = dfa40.predict(input); |
| switch (alt40) { |
| case 1 : |
| // InternalSEW.g:2348:2: ( ruleDeprecatedAttribute ) |
| { |
| // InternalSEW.g:2348:2: ( ruleDeprecatedAttribute ) |
| // InternalSEW.g:2349:3: ruleDeprecatedAttribute |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedAttributeParserRuleCall_0_3_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedAttribute(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedAttributeParserRuleCall_0_3_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2354:2: ( ruleDeprecatedObject ) |
| { |
| // InternalSEW.g:2354:2: ( ruleDeprecatedObject ) |
| // InternalSEW.g:2355:3: ruleDeprecatedObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedObjectParserRuleCall_0_3_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedObjectParserRuleCall_0_3_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:2360:2: ( ruleObject ) |
| { |
| // InternalSEW.g:2360:2: ( ruleObject ) |
| // InternalSEW.g:2361:3: ruleObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementObjectParserRuleCall_0_3_0_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementObjectParserRuleCall_0_3_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__ElementAlternatives_0_3_0" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Alternatives_1_2" |
| // InternalSEW.g:2370:1: rule__DeprecatedSection__Alternatives_1_2 : ( ( ( rule__DeprecatedSection__Group_1_2_0__0 ) ) | ( ( rule__DeprecatedSection__Group_1_2_1__0 ) ) ); |
| public final void rule__DeprecatedSection__Alternatives_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2374:1: ( ( ( rule__DeprecatedSection__Group_1_2_0__0 ) ) | ( ( rule__DeprecatedSection__Group_1_2_1__0 ) ) ) |
| int alt41=2; |
| int LA41_0 = input.LA(1); |
| |
| if ( (LA41_0==55) ) { |
| alt41=1; |
| } |
| else if ( (LA41_0==57) ) { |
| alt41=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 41, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt41) { |
| case 1 : |
| // InternalSEW.g:2375:2: ( ( rule__DeprecatedSection__Group_1_2_0__0 ) ) |
| { |
| // InternalSEW.g:2375:2: ( ( rule__DeprecatedSection__Group_1_2_0__0 ) ) |
| // InternalSEW.g:2376:3: ( rule__DeprecatedSection__Group_1_2_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getGroup_1_2_0()); |
| } |
| // InternalSEW.g:2377:3: ( rule__DeprecatedSection__Group_1_2_0__0 ) |
| // InternalSEW.g:2377:4: rule__DeprecatedSection__Group_1_2_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_1_2_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getGroup_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2381:2: ( ( rule__DeprecatedSection__Group_1_2_1__0 ) ) |
| { |
| // InternalSEW.g:2381:2: ( ( rule__DeprecatedSection__Group_1_2_1__0 ) ) |
| // InternalSEW.g:2382:3: ( rule__DeprecatedSection__Group_1_2_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getGroup_1_2_1()); |
| } |
| // InternalSEW.g:2383:3: ( rule__DeprecatedSection__Group_1_2_1__0 ) |
| // InternalSEW.g:2383:4: rule__DeprecatedSection__Group_1_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_1_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getGroup_1_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Alternatives_1_2" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0" |
| // InternalSEW.g:2391:1: rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0 : ( ( ruleDeprecatedAttribute ) | ( ruleDeprecatedObject ) | ( ruleObject ) ); |
| public final void rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2395:1: ( ( ruleDeprecatedAttribute ) | ( ruleDeprecatedObject ) | ( ruleObject ) ) |
| int alt42=3; |
| alt42 = dfa42.predict(input); |
| switch (alt42) { |
| case 1 : |
| // InternalSEW.g:2396:2: ( ruleDeprecatedAttribute ) |
| { |
| // InternalSEW.g:2396:2: ( ruleDeprecatedAttribute ) |
| // InternalSEW.g:2397:3: ruleDeprecatedAttribute |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedAttributeParserRuleCall_1_2_0_1_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedAttribute(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedAttributeParserRuleCall_1_2_0_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2402:2: ( ruleDeprecatedObject ) |
| { |
| // InternalSEW.g:2402:2: ( ruleDeprecatedObject ) |
| // InternalSEW.g:2403:3: ruleDeprecatedObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedObjectParserRuleCall_1_2_0_1_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedObjectParserRuleCall_1_2_0_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:2408:2: ( ruleObject ) |
| { |
| // InternalSEW.g:2408:2: ( ruleObject ) |
| // InternalSEW.g:2409:3: ruleObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementObjectParserRuleCall_1_2_0_1_0_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementObjectParserRuleCall_1_2_0_1_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0" |
| // InternalSEW.g:2418:1: rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0 : ( ( ruleDeprecatedAttribute ) | ( ruleDeprecatedObject ) | ( ruleObject ) ); |
| public final void rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2422:1: ( ( ruleDeprecatedAttribute ) | ( ruleDeprecatedObject ) | ( ruleObject ) ) |
| int alt43=3; |
| alt43 = dfa43.predict(input); |
| switch (alt43) { |
| case 1 : |
| // InternalSEW.g:2423:2: ( ruleDeprecatedAttribute ) |
| { |
| // InternalSEW.g:2423:2: ( ruleDeprecatedAttribute ) |
| // InternalSEW.g:2424:3: ruleDeprecatedAttribute |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedAttributeParserRuleCall_1_2_1_1_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedAttribute(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedAttributeParserRuleCall_1_2_1_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2429:2: ( ruleDeprecatedObject ) |
| { |
| // InternalSEW.g:2429:2: ( ruleDeprecatedObject ) |
| // InternalSEW.g:2430:3: ruleDeprecatedObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedObjectParserRuleCall_1_2_1_1_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementDeprecatedObjectParserRuleCall_1_2_1_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalSEW.g:2435:2: ( ruleObject ) |
| { |
| // InternalSEW.g:2435:2: ( ruleObject ) |
| // InternalSEW.g:2436:3: ruleObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementObjectParserRuleCall_1_2_1_1_0_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementObjectParserRuleCall_1_2_1_1_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttributeID__Alternatives" |
| // InternalSEW.g:2445:1: rule__DeprecatedAttributeID__Alternatives : ( ( ruleXID ) | ( RULE_AT_IDENTIFIER ) ); |
| public final void rule__DeprecatedAttributeID__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2449:1: ( ( ruleXID ) | ( RULE_AT_IDENTIFIER ) ) |
| int alt44=2; |
| int LA44_0 = input.LA(1); |
| |
| if ( (LA44_0==RULE_XIDENDIFIER||LA44_0==14||LA44_0==18||(LA44_0>=42 && LA44_0<=47)) ) { |
| alt44=1; |
| } |
| else if ( (LA44_0==RULE_AT_IDENTIFIER) ) { |
| alt44=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 44, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt44) { |
| case 1 : |
| // InternalSEW.g:2450:2: ( ruleXID ) |
| { |
| // InternalSEW.g:2450:2: ( ruleXID ) |
| // InternalSEW.g:2451:3: ruleXID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeIDAccess().getXIDParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleXID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeIDAccess().getXIDParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2456:2: ( RULE_AT_IDENTIFIER ) |
| { |
| // InternalSEW.g:2456:2: ( RULE_AT_IDENTIFIER ) |
| // InternalSEW.g:2457:3: RULE_AT_IDENTIFIER |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeIDAccess().getAT_IDENTIFIERTerminalRuleCall_1()); |
| } |
| match(input,RULE_AT_IDENTIFIER,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeIDAccess().getAT_IDENTIFIERTerminalRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttributeID__Alternatives" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__OperatorAlternatives_2_0" |
| // InternalSEW.g:2466:1: rule__DeprecatedExpression__OperatorAlternatives_2_0 : ( ( '|;|' ) | ( '|i|' ) ); |
| public final void rule__DeprecatedExpression__OperatorAlternatives_2_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2470:1: ( ( '|;|' ) | ( '|i|' ) ) |
| int alt45=2; |
| int LA45_0 = input.LA(1); |
| |
| if ( (LA45_0==48) ) { |
| alt45=1; |
| } |
| else if ( (LA45_0==49) ) { |
| alt45=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 45, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt45) { |
| case 1 : |
| // InternalSEW.g:2471:2: ( '|;|' ) |
| { |
| // InternalSEW.g:2471:2: ( '|;|' ) |
| // InternalSEW.g:2472:3: '|;|' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedExpressionAccess().getOperatorVerticalLineSemicolonVerticalLineKeyword_2_0_0()); |
| } |
| match(input,48,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedExpressionAccess().getOperatorVerticalLineSemicolonVerticalLineKeyword_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalSEW.g:2477:2: ( '|i|' ) |
| { |
| // InternalSEW.g:2477:2: ( '|i|' ) |
| // InternalSEW.g:2478:3: '|i|' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedExpressionAccess().getOperatorIKeyword_2_0_1()); |
| } |
| match(input,49,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedExpressionAccess().getOperatorIKeyword_2_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__OperatorAlternatives_2_0" |
| |
| |
| // $ANTLR start "rule__Workflow__Group__0" |
| // InternalSEW.g:2487:1: rule__Workflow__Group__0 : rule__Workflow__Group__0__Impl rule__Workflow__Group__1 ; |
| public final void rule__Workflow__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2491:1: ( rule__Workflow__Group__0__Impl rule__Workflow__Group__1 ) |
| // InternalSEW.g:2492:2: rule__Workflow__Group__0__Impl rule__Workflow__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_4); |
| rule__Workflow__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group__0" |
| |
| |
| // $ANTLR start "rule__Workflow__Group__0__Impl" |
| // InternalSEW.g:2499:1: rule__Workflow__Group__0__Impl : ( () ) ; |
| public final void rule__Workflow__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2503:1: ( ( () ) ) |
| // InternalSEW.g:2504:1: ( () ) |
| { |
| // InternalSEW.g:2504:1: ( () ) |
| // InternalSEW.g:2505:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getSEWorkflowAction_0()); |
| } |
| // InternalSEW.g:2506:2: () |
| // InternalSEW.g:2506:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getSEWorkflowAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__Workflow__Group__1" |
| // InternalSEW.g:2514:1: rule__Workflow__Group__1 : rule__Workflow__Group__1__Impl rule__Workflow__Group__2 ; |
| public final void rule__Workflow__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2518:1: ( rule__Workflow__Group__1__Impl rule__Workflow__Group__2 ) |
| // InternalSEW.g:2519:2: rule__Workflow__Group__1__Impl rule__Workflow__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_4); |
| rule__Workflow__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group__1" |
| |
| |
| // $ANTLR start "rule__Workflow__Group__1__Impl" |
| // InternalSEW.g:2526:1: rule__Workflow__Group__1__Impl : ( ( ruleProlog )? ) ; |
| public final void rule__Workflow__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2530:1: ( ( ( ruleProlog )? ) ) |
| // InternalSEW.g:2531:1: ( ( ruleProlog )? ) |
| { |
| // InternalSEW.g:2531:1: ( ( ruleProlog )? ) |
| // InternalSEW.g:2532:2: ( ruleProlog )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getPrologParserRuleCall_1()); |
| } |
| // InternalSEW.g:2533:2: ( ruleProlog )? |
| int alt46=2; |
| int LA46_0 = input.LA(1); |
| |
| if ( ((LA46_0>=16 && LA46_0<=17)) ) { |
| alt46=1; |
| } |
| switch (alt46) { |
| case 1 : |
| // InternalSEW.g:2533:3: ruleProlog |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleProlog(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getPrologParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Workflow__Group__2" |
| // InternalSEW.g:2541:1: rule__Workflow__Group__2 : rule__Workflow__Group__2__Impl ; |
| public final void rule__Workflow__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2545:1: ( rule__Workflow__Group__2__Impl ) |
| // InternalSEW.g:2546:2: rule__Workflow__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group__2" |
| |
| |
| // $ANTLR start "rule__Workflow__Group__2__Impl" |
| // InternalSEW.g:2552:1: rule__Workflow__Group__2__Impl : ( ( rule__Workflow__Alternatives_2 ) ) ; |
| public final void rule__Workflow__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2556:1: ( ( ( rule__Workflow__Alternatives_2 ) ) ) |
| // InternalSEW.g:2557:1: ( ( rule__Workflow__Alternatives_2 ) ) |
| { |
| // InternalSEW.g:2557:1: ( ( rule__Workflow__Alternatives_2 ) ) |
| // InternalSEW.g:2558:2: ( rule__Workflow__Alternatives_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getAlternatives_2()); |
| } |
| // InternalSEW.g:2559:2: ( rule__Workflow__Alternatives_2 ) |
| // InternalSEW.g:2559:3: rule__Workflow__Alternatives_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Alternatives_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getAlternatives_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__0" |
| // InternalSEW.g:2568:1: rule__Workflow__Group_2_0__0 : rule__Workflow__Group_2_0__0__Impl rule__Workflow__Group_2_0__1 ; |
| public final void rule__Workflow__Group_2_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2572:1: ( rule__Workflow__Group_2_0__0__Impl rule__Workflow__Group_2_0__1 ) |
| // InternalSEW.g:2573:2: rule__Workflow__Group_2_0__0__Impl rule__Workflow__Group_2_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_5); |
| rule__Workflow__Group_2_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group_2_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__0" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__0__Impl" |
| // InternalSEW.g:2580:1: rule__Workflow__Group_2_0__0__Impl : ( ( rule__Workflow__TypeAssignment_2_0_0 ) ) ; |
| public final void rule__Workflow__Group_2_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2584:1: ( ( ( rule__Workflow__TypeAssignment_2_0_0 ) ) ) |
| // InternalSEW.g:2585:1: ( ( rule__Workflow__TypeAssignment_2_0_0 ) ) |
| { |
| // InternalSEW.g:2585:1: ( ( rule__Workflow__TypeAssignment_2_0_0 ) ) |
| // InternalSEW.g:2586:2: ( rule__Workflow__TypeAssignment_2_0_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getTypeAssignment_2_0_0()); |
| } |
| // InternalSEW.g:2587:2: ( rule__Workflow__TypeAssignment_2_0_0 ) |
| // InternalSEW.g:2587:3: rule__Workflow__TypeAssignment_2_0_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__TypeAssignment_2_0_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getTypeAssignment_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__1" |
| // InternalSEW.g:2595:1: rule__Workflow__Group_2_0__1 : rule__Workflow__Group_2_0__1__Impl rule__Workflow__Group_2_0__2 ; |
| public final void rule__Workflow__Group_2_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2599:1: ( rule__Workflow__Group_2_0__1__Impl rule__Workflow__Group_2_0__2 ) |
| // InternalSEW.g:2600:2: rule__Workflow__Group_2_0__1__Impl rule__Workflow__Group_2_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_5); |
| rule__Workflow__Group_2_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group_2_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__1" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__1__Impl" |
| // InternalSEW.g:2607:1: rule__Workflow__Group_2_0__1__Impl : ( ( rule__Workflow__NameAssignment_2_0_1 )? ) ; |
| public final void rule__Workflow__Group_2_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2611:1: ( ( ( rule__Workflow__NameAssignment_2_0_1 )? ) ) |
| // InternalSEW.g:2612:1: ( ( rule__Workflow__NameAssignment_2_0_1 )? ) |
| { |
| // InternalSEW.g:2612:1: ( ( rule__Workflow__NameAssignment_2_0_1 )? ) |
| // InternalSEW.g:2613:2: ( rule__Workflow__NameAssignment_2_0_1 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getNameAssignment_2_0_1()); |
| } |
| // InternalSEW.g:2614:2: ( rule__Workflow__NameAssignment_2_0_1 )? |
| int alt47=2; |
| int LA47_0 = input.LA(1); |
| |
| if ( (LA47_0==RULE_XIDENDIFIER||LA47_0==14||LA47_0==18||(LA47_0>=42 && LA47_0<=47)) ) { |
| alt47=1; |
| } |
| switch (alt47) { |
| case 1 : |
| // InternalSEW.g:2614:3: rule__Workflow__NameAssignment_2_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__NameAssignment_2_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getNameAssignment_2_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__2" |
| // InternalSEW.g:2622:1: rule__Workflow__Group_2_0__2 : rule__Workflow__Group_2_0__2__Impl rule__Workflow__Group_2_0__3 ; |
| public final void rule__Workflow__Group_2_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2626:1: ( rule__Workflow__Group_2_0__2__Impl rule__Workflow__Group_2_0__3 ) |
| // InternalSEW.g:2627:2: rule__Workflow__Group_2_0__2__Impl rule__Workflow__Group_2_0__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_5); |
| rule__Workflow__Group_2_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group_2_0__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__2" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__2__Impl" |
| // InternalSEW.g:2634:1: rule__Workflow__Group_2_0__2__Impl : ( ( rule__Workflow__DescriptionAssignment_2_0_2 )? ) ; |
| public final void rule__Workflow__Group_2_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2638:1: ( ( ( rule__Workflow__DescriptionAssignment_2_0_2 )? ) ) |
| // InternalSEW.g:2639:1: ( ( rule__Workflow__DescriptionAssignment_2_0_2 )? ) |
| { |
| // InternalSEW.g:2639:1: ( ( rule__Workflow__DescriptionAssignment_2_0_2 )? ) |
| // InternalSEW.g:2640:2: ( rule__Workflow__DescriptionAssignment_2_0_2 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getDescriptionAssignment_2_0_2()); |
| } |
| // InternalSEW.g:2641:2: ( rule__Workflow__DescriptionAssignment_2_0_2 )? |
| int alt48=2; |
| int LA48_0 = input.LA(1); |
| |
| if ( (LA48_0==RULE_STRING) ) { |
| alt48=1; |
| } |
| switch (alt48) { |
| case 1 : |
| // InternalSEW.g:2641:3: rule__Workflow__DescriptionAssignment_2_0_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__DescriptionAssignment_2_0_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getDescriptionAssignment_2_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__3" |
| // InternalSEW.g:2649:1: rule__Workflow__Group_2_0__3 : rule__Workflow__Group_2_0__3__Impl rule__Workflow__Group_2_0__4 ; |
| public final void rule__Workflow__Group_2_0__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2653:1: ( rule__Workflow__Group_2_0__3__Impl rule__Workflow__Group_2_0__4 ) |
| // InternalSEW.g:2654:2: rule__Workflow__Group_2_0__3__Impl rule__Workflow__Group_2_0__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__Workflow__Group_2_0__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group_2_0__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__3" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__3__Impl" |
| // InternalSEW.g:2661:1: rule__Workflow__Group_2_0__3__Impl : ( '{' ) ; |
| public final void rule__Workflow__Group_2_0__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2665:1: ( ( '{' ) ) |
| // InternalSEW.g:2666:1: ( '{' ) |
| { |
| // InternalSEW.g:2666:1: ( '{' ) |
| // InternalSEW.g:2667:2: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getLeftCurlyBracketKeyword_2_0_3()); |
| } |
| match(input,50,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getLeftCurlyBracketKeyword_2_0_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__3__Impl" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__4" |
| // InternalSEW.g:2676:1: rule__Workflow__Group_2_0__4 : rule__Workflow__Group_2_0__4__Impl rule__Workflow__Group_2_0__5 ; |
| public final void rule__Workflow__Group_2_0__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2680:1: ( rule__Workflow__Group_2_0__4__Impl rule__Workflow__Group_2_0__5 ) |
| // InternalSEW.g:2681:2: rule__Workflow__Group_2_0__4__Impl rule__Workflow__Group_2_0__5 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__Workflow__Group_2_0__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group_2_0__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__4" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__4__Impl" |
| // InternalSEW.g:2688:1: rule__Workflow__Group_2_0__4__Impl : ( ( rule__Workflow__ElementAssignment_2_0_4 )* ) ; |
| public final void rule__Workflow__Group_2_0__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2692:1: ( ( ( rule__Workflow__ElementAssignment_2_0_4 )* ) ) |
| // InternalSEW.g:2693:1: ( ( rule__Workflow__ElementAssignment_2_0_4 )* ) |
| { |
| // InternalSEW.g:2693:1: ( ( rule__Workflow__ElementAssignment_2_0_4 )* ) |
| // InternalSEW.g:2694:2: ( rule__Workflow__ElementAssignment_2_0_4 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getElementAssignment_2_0_4()); |
| } |
| // InternalSEW.g:2695:2: ( rule__Workflow__ElementAssignment_2_0_4 )* |
| loop49: |
| do { |
| int alt49=2; |
| int LA49_0 = input.LA(1); |
| |
| if ( (LA49_0==RULE_XIDENDIFIER||LA49_0==14||LA49_0==18||(LA49_0>=42 && LA49_0<=47)) ) { |
| alt49=1; |
| } |
| |
| |
| switch (alt49) { |
| case 1 : |
| // InternalSEW.g:2695:3: rule__Workflow__ElementAssignment_2_0_4 |
| { |
| pushFollow(FollowSets000.FOLLOW_3); |
| rule__Workflow__ElementAssignment_2_0_4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop49; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getElementAssignment_2_0_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__4__Impl" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__5" |
| // InternalSEW.g:2703:1: rule__Workflow__Group_2_0__5 : rule__Workflow__Group_2_0__5__Impl ; |
| public final void rule__Workflow__Group_2_0__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2707:1: ( rule__Workflow__Group_2_0__5__Impl ) |
| // InternalSEW.g:2708:2: rule__Workflow__Group_2_0__5__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group_2_0__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__5" |
| |
| |
| // $ANTLR start "rule__Workflow__Group_2_0__5__Impl" |
| // InternalSEW.g:2714:1: rule__Workflow__Group_2_0__5__Impl : ( '}' ) ; |
| public final void rule__Workflow__Group_2_0__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2718:1: ( ( '}' ) ) |
| // InternalSEW.g:2719:1: ( '}' ) |
| { |
| // InternalSEW.g:2719:1: ( '}' ) |
| // InternalSEW.g:2720:2: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getRightCurlyBracketKeyword_2_0_5()); |
| } |
| match(input,51,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getRightCurlyBracketKeyword_2_0_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__Group_2_0__5__Impl" |
| |
| |
| // $ANTLR start "rule__Prolog__Group__0" |
| // InternalSEW.g:2730:1: rule__Prolog__Group__0 : rule__Prolog__Group__0__Impl rule__Prolog__Group__1 ; |
| public final void rule__Prolog__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2734:1: ( rule__Prolog__Group__0__Impl rule__Prolog__Group__1 ) |
| // InternalSEW.g:2735:2: rule__Prolog__Group__0__Impl rule__Prolog__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_7); |
| rule__Prolog__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group__0" |
| |
| |
| // $ANTLR start "rule__Prolog__Group__0__Impl" |
| // InternalSEW.g:2742:1: rule__Prolog__Group__0__Impl : ( ( rule__Prolog__Alternatives_0 ) ) ; |
| public final void rule__Prolog__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2746:1: ( ( ( rule__Prolog__Alternatives_0 ) ) ) |
| // InternalSEW.g:2747:1: ( ( rule__Prolog__Alternatives_0 ) ) |
| { |
| // InternalSEW.g:2747:1: ( ( rule__Prolog__Alternatives_0 ) ) |
| // InternalSEW.g:2748:2: ( rule__Prolog__Alternatives_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getAlternatives_0()); |
| } |
| // InternalSEW.g:2749:2: ( rule__Prolog__Alternatives_0 ) |
| // InternalSEW.g:2749:3: rule__Prolog__Alternatives_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Alternatives_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getAlternatives_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__Prolog__Group__1" |
| // InternalSEW.g:2757:1: rule__Prolog__Group__1 : rule__Prolog__Group__1__Impl rule__Prolog__Group__2 ; |
| public final void rule__Prolog__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2761:1: ( rule__Prolog__Group__1__Impl rule__Prolog__Group__2 ) |
| // InternalSEW.g:2762:2: rule__Prolog__Group__1__Impl rule__Prolog__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_8); |
| rule__Prolog__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group__1" |
| |
| |
| // $ANTLR start "rule__Prolog__Group__1__Impl" |
| // InternalSEW.g:2769:1: rule__Prolog__Group__1__Impl : ( '<' ) ; |
| public final void rule__Prolog__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2773:1: ( ( '<' ) ) |
| // InternalSEW.g:2774:1: ( '<' ) |
| { |
| // InternalSEW.g:2774:1: ( '<' ) |
| // InternalSEW.g:2775:2: '<' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getLessThanSignKeyword_1()); |
| } |
| match(input,32,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getLessThanSignKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Prolog__Group__2" |
| // InternalSEW.g:2784:1: rule__Prolog__Group__2 : rule__Prolog__Group__2__Impl rule__Prolog__Group__3 ; |
| public final void rule__Prolog__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2788:1: ( rule__Prolog__Group__2__Impl rule__Prolog__Group__3 ) |
| // InternalSEW.g:2789:2: rule__Prolog__Group__2__Impl rule__Prolog__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_9); |
| rule__Prolog__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group__2" |
| |
| |
| // $ANTLR start "rule__Prolog__Group__2__Impl" |
| // InternalSEW.g:2796:1: rule__Prolog__Group__2__Impl : ( ( rule__Prolog__Alternatives_2 ) ) ; |
| public final void rule__Prolog__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2800:1: ( ( ( rule__Prolog__Alternatives_2 ) ) ) |
| // InternalSEW.g:2801:1: ( ( rule__Prolog__Alternatives_2 ) ) |
| { |
| // InternalSEW.g:2801:1: ( ( rule__Prolog__Alternatives_2 ) ) |
| // InternalSEW.g:2802:2: ( rule__Prolog__Alternatives_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getAlternatives_2()); |
| } |
| // InternalSEW.g:2803:2: ( rule__Prolog__Alternatives_2 ) |
| // InternalSEW.g:2803:3: rule__Prolog__Alternatives_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Alternatives_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getAlternatives_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__Prolog__Group__3" |
| // InternalSEW.g:2811:1: rule__Prolog__Group__3 : rule__Prolog__Group__3__Impl rule__Prolog__Group__4 ; |
| public final void rule__Prolog__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2815:1: ( rule__Prolog__Group__3__Impl rule__Prolog__Group__4 ) |
| // InternalSEW.g:2816:2: rule__Prolog__Group__3__Impl rule__Prolog__Group__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_9); |
| rule__Prolog__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group__3" |
| |
| |
| // $ANTLR start "rule__Prolog__Group__3__Impl" |
| // InternalSEW.g:2823:1: rule__Prolog__Group__3__Impl : ( ( rule__Prolog__Alternatives_3 )? ) ; |
| public final void rule__Prolog__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2827:1: ( ( ( rule__Prolog__Alternatives_3 )? ) ) |
| // InternalSEW.g:2828:1: ( ( rule__Prolog__Alternatives_3 )? ) |
| { |
| // InternalSEW.g:2828:1: ( ( rule__Prolog__Alternatives_3 )? ) |
| // InternalSEW.g:2829:2: ( rule__Prolog__Alternatives_3 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getAlternatives_3()); |
| } |
| // InternalSEW.g:2830:2: ( rule__Prolog__Alternatives_3 )? |
| int alt50=2; |
| int LA50_0 = input.LA(1); |
| |
| if ( ((LA50_0>=RULE_STRING && LA50_0<=RULE_XIDENDIFIER)||LA50_0==14||LA50_0==18||(LA50_0>=42 && LA50_0<=47)||LA50_0==53) ) { |
| alt50=1; |
| } |
| switch (alt50) { |
| case 1 : |
| // InternalSEW.g:2830:3: rule__Prolog__Alternatives_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Alternatives_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getAlternatives_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__Prolog__Group__4" |
| // InternalSEW.g:2838:1: rule__Prolog__Group__4 : rule__Prolog__Group__4__Impl ; |
| public final void rule__Prolog__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2842:1: ( rule__Prolog__Group__4__Impl ) |
| // InternalSEW.g:2843:2: rule__Prolog__Group__4__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group__4" |
| |
| |
| // $ANTLR start "rule__Prolog__Group__4__Impl" |
| // InternalSEW.g:2849:1: rule__Prolog__Group__4__Impl : ( '>:' ) ; |
| public final void rule__Prolog__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2853:1: ( ( '>:' ) ) |
| // InternalSEW.g:2854:1: ( '>:' ) |
| { |
| // InternalSEW.g:2854:1: ( '>:' ) |
| // InternalSEW.g:2855:2: '>:' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getGreaterThanSignColonKeyword_4()); |
| } |
| match(input,52,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getGreaterThanSignColonKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__Prolog__Group_3_0__0" |
| // InternalSEW.g:2865:1: rule__Prolog__Group_3_0__0 : rule__Prolog__Group_3_0__0__Impl rule__Prolog__Group_3_0__1 ; |
| public final void rule__Prolog__Group_3_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2869:1: ( rule__Prolog__Group_3_0__0__Impl rule__Prolog__Group_3_0__1 ) |
| // InternalSEW.g:2870:2: rule__Prolog__Group_3_0__0__Impl rule__Prolog__Group_3_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_10); |
| rule__Prolog__Group_3_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Group_3_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group_3_0__0" |
| |
| |
| // $ANTLR start "rule__Prolog__Group_3_0__0__Impl" |
| // InternalSEW.g:2877:1: rule__Prolog__Group_3_0__0__Impl : ( ',' ) ; |
| public final void rule__Prolog__Group_3_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2881:1: ( ( ',' ) ) |
| // InternalSEW.g:2882:1: ( ',' ) |
| { |
| // InternalSEW.g:2882:1: ( ',' ) |
| // InternalSEW.g:2883:2: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getCommaKeyword_3_0_0()); |
| } |
| match(input,53,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getCommaKeyword_3_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group_3_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__Prolog__Group_3_0__1" |
| // InternalSEW.g:2892:1: rule__Prolog__Group_3_0__1 : rule__Prolog__Group_3_0__1__Impl rule__Prolog__Group_3_0__2 ; |
| public final void rule__Prolog__Group_3_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2896:1: ( rule__Prolog__Group_3_0__1__Impl rule__Prolog__Group_3_0__2 ) |
| // InternalSEW.g:2897:2: rule__Prolog__Group_3_0__1__Impl rule__Prolog__Group_3_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_10); |
| rule__Prolog__Group_3_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Group_3_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group_3_0__1" |
| |
| |
| // $ANTLR start "rule__Prolog__Group_3_0__1__Impl" |
| // InternalSEW.g:2904:1: rule__Prolog__Group_3_0__1__Impl : ( ( 'version:' )? ) ; |
| public final void rule__Prolog__Group_3_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2908:1: ( ( ( 'version:' )? ) ) |
| // InternalSEW.g:2909:1: ( ( 'version:' )? ) |
| { |
| // InternalSEW.g:2909:1: ( ( 'version:' )? ) |
| // InternalSEW.g:2910:2: ( 'version:' )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getVersionKeyword_3_0_1()); |
| } |
| // InternalSEW.g:2911:2: ( 'version:' )? |
| int alt51=2; |
| int LA51_0 = input.LA(1); |
| |
| if ( (LA51_0==54) ) { |
| alt51=1; |
| } |
| switch (alt51) { |
| case 1 : |
| // InternalSEW.g:2911:3: 'version:' |
| { |
| match(input,54,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getVersionKeyword_3_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group_3_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__Prolog__Group_3_0__2" |
| // InternalSEW.g:2919:1: rule__Prolog__Group_3_0__2 : rule__Prolog__Group_3_0__2__Impl ; |
| public final void rule__Prolog__Group_3_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2923:1: ( rule__Prolog__Group_3_0__2__Impl ) |
| // InternalSEW.g:2924:2: rule__Prolog__Group_3_0__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Prolog__Group_3_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group_3_0__2" |
| |
| |
| // $ANTLR start "rule__Prolog__Group_3_0__2__Impl" |
| // InternalSEW.g:2930:1: rule__Prolog__Group_3_0__2__Impl : ( ruleEDouble ) ; |
| public final void rule__Prolog__Group_3_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2934:1: ( ( ruleEDouble ) ) |
| // InternalSEW.g:2935:1: ( ruleEDouble ) |
| { |
| // InternalSEW.g:2935:1: ( ruleEDouble ) |
| // InternalSEW.g:2936:2: ruleEDouble |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrologAccess().getEDoubleParserRuleCall_3_0_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEDouble(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrologAccess().getEDoubleParserRuleCall_3_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Prolog__Group_3_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__UFI__Group__0" |
| // InternalSEW.g:2946:1: rule__UFI__Group__0 : rule__UFI__Group__0__Impl rule__UFI__Group__1 ; |
| public final void rule__UFI__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2950:1: ( rule__UFI__Group__0__Impl rule__UFI__Group__1 ) |
| // InternalSEW.g:2951:2: rule__UFI__Group__0__Impl rule__UFI__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_11); |
| rule__UFI__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__UFI__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UFI__Group__0" |
| |
| |
| // $ANTLR start "rule__UFI__Group__0__Impl" |
| // InternalSEW.g:2958:1: rule__UFI__Group__0__Impl : ( ruleXID ) ; |
| public final void rule__UFI__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2962:1: ( ( ruleXID ) ) |
| // InternalSEW.g:2963:1: ( ruleXID ) |
| { |
| // InternalSEW.g:2963:1: ( ruleXID ) |
| // InternalSEW.g:2964:2: ruleXID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUFIAccess().getXIDParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleXID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUFIAccess().getXIDParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UFI__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__UFI__Group__1" |
| // InternalSEW.g:2973:1: rule__UFI__Group__1 : rule__UFI__Group__1__Impl ; |
| public final void rule__UFI__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2977:1: ( rule__UFI__Group__1__Impl ) |
| // InternalSEW.g:2978:2: rule__UFI__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__UFI__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UFI__Group__1" |
| |
| |
| // $ANTLR start "rule__UFI__Group__1__Impl" |
| // InternalSEW.g:2984:1: rule__UFI__Group__1__Impl : ( ( rule__UFI__Group_1__0 )* ) ; |
| public final void rule__UFI__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:2988:1: ( ( ( rule__UFI__Group_1__0 )* ) ) |
| // InternalSEW.g:2989:1: ( ( rule__UFI__Group_1__0 )* ) |
| { |
| // InternalSEW.g:2989:1: ( ( rule__UFI__Group_1__0 )* ) |
| // InternalSEW.g:2990:2: ( rule__UFI__Group_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUFIAccess().getGroup_1()); |
| } |
| // InternalSEW.g:2991:2: ( rule__UFI__Group_1__0 )* |
| loop52: |
| do { |
| int alt52=2; |
| int LA52_0 = input.LA(1); |
| |
| if ( (LA52_0==20) ) { |
| int LA52_2 = input.LA(2); |
| |
| if ( (LA52_2==RULE_XIDENDIFIER||LA52_2==14||LA52_2==18||(LA52_2>=42 && LA52_2<=47)) ) { |
| alt52=1; |
| } |
| |
| |
| } |
| else if ( (LA52_0==19) ) { |
| alt52=1; |
| } |
| |
| |
| switch (alt52) { |
| case 1 : |
| // InternalSEW.g:2991:3: rule__UFI__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__UFI__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop52; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUFIAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UFI__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__UFI__Group_1__0" |
| // InternalSEW.g:3000:1: rule__UFI__Group_1__0 : rule__UFI__Group_1__0__Impl rule__UFI__Group_1__1 ; |
| public final void rule__UFI__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3004:1: ( rule__UFI__Group_1__0__Impl rule__UFI__Group_1__1 ) |
| // InternalSEW.g:3005:2: rule__UFI__Group_1__0__Impl rule__UFI__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__UFI__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__UFI__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UFI__Group_1__0" |
| |
| |
| // $ANTLR start "rule__UFI__Group_1__0__Impl" |
| // InternalSEW.g:3012:1: rule__UFI__Group_1__0__Impl : ( ( rule__UFI__Alternatives_1_0 ) ) ; |
| public final void rule__UFI__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3016:1: ( ( ( rule__UFI__Alternatives_1_0 ) ) ) |
| // InternalSEW.g:3017:1: ( ( rule__UFI__Alternatives_1_0 ) ) |
| { |
| // InternalSEW.g:3017:1: ( ( rule__UFI__Alternatives_1_0 ) ) |
| // InternalSEW.g:3018:2: ( rule__UFI__Alternatives_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUFIAccess().getAlternatives_1_0()); |
| } |
| // InternalSEW.g:3019:2: ( rule__UFI__Alternatives_1_0 ) |
| // InternalSEW.g:3019:3: rule__UFI__Alternatives_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__UFI__Alternatives_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUFIAccess().getAlternatives_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UFI__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__UFI__Group_1__1" |
| // InternalSEW.g:3027:1: rule__UFI__Group_1__1 : rule__UFI__Group_1__1__Impl ; |
| public final void rule__UFI__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3031:1: ( rule__UFI__Group_1__1__Impl ) |
| // InternalSEW.g:3032:2: rule__UFI__Group_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__UFI__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UFI__Group_1__1" |
| |
| |
| // $ANTLR start "rule__UFI__Group_1__1__Impl" |
| // InternalSEW.g:3038:1: rule__UFI__Group_1__1__Impl : ( ruleXID ) ; |
| public final void rule__UFI__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3042:1: ( ( ruleXID ) ) |
| // InternalSEW.g:3043:1: ( ruleXID ) |
| { |
| // InternalSEW.g:3043:1: ( ruleXID ) |
| // InternalSEW.g:3044:2: ruleXID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUFIAccess().getXIDParserRuleCall_1_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleXID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUFIAccess().getXIDParserRuleCall_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UFI__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__0" |
| // InternalSEW.g:3054:1: rule__Object__Group_0__0 : rule__Object__Group_0__0__Impl rule__Object__Group_0__1 ; |
| public final void rule__Object__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3058:1: ( rule__Object__Group_0__0__Impl rule__Object__Group_0__1 ) |
| // InternalSEW.g:3059:2: rule__Object__Group_0__0__Impl rule__Object__Group_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__Object__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__0" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__0__Impl" |
| // InternalSEW.g:3066:1: rule__Object__Group_0__0__Impl : ( () ) ; |
| public final void rule__Object__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3070:1: ( ( () ) ) |
| // InternalSEW.g:3071:1: ( () ) |
| { |
| // InternalSEW.g:3071:1: ( () ) |
| // InternalSEW.g:3072:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getWObjectAction_0_0()); |
| } |
| // InternalSEW.g:3073:2: () |
| // InternalSEW.g:3073:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getWObjectAction_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__1" |
| // InternalSEW.g:3081:1: rule__Object__Group_0__1 : rule__Object__Group_0__1__Impl rule__Object__Group_0__2 ; |
| public final void rule__Object__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3085:1: ( rule__Object__Group_0__1__Impl rule__Object__Group_0__2 ) |
| // InternalSEW.g:3086:2: rule__Object__Group_0__1__Impl rule__Object__Group_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_5); |
| rule__Object__Group_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__1" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__1__Impl" |
| // InternalSEW.g:3093:1: rule__Object__Group_0__1__Impl : ( ( rule__Object__TypeAssignment_0_1 ) ) ; |
| public final void rule__Object__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3097:1: ( ( ( rule__Object__TypeAssignment_0_1 ) ) ) |
| // InternalSEW.g:3098:1: ( ( rule__Object__TypeAssignment_0_1 ) ) |
| { |
| // InternalSEW.g:3098:1: ( ( rule__Object__TypeAssignment_0_1 ) ) |
| // InternalSEW.g:3099:2: ( rule__Object__TypeAssignment_0_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getTypeAssignment_0_1()); |
| } |
| // InternalSEW.g:3100:2: ( rule__Object__TypeAssignment_0_1 ) |
| // InternalSEW.g:3100:3: rule__Object__TypeAssignment_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__TypeAssignment_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getTypeAssignment_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__2" |
| // InternalSEW.g:3108:1: rule__Object__Group_0__2 : rule__Object__Group_0__2__Impl rule__Object__Group_0__3 ; |
| public final void rule__Object__Group_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3112:1: ( rule__Object__Group_0__2__Impl rule__Object__Group_0__3 ) |
| // InternalSEW.g:3113:2: rule__Object__Group_0__2__Impl rule__Object__Group_0__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_5); |
| rule__Object__Group_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_0__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__2" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__2__Impl" |
| // InternalSEW.g:3120:1: rule__Object__Group_0__2__Impl : ( ( rule__Object__NameAssignment_0_2 )? ) ; |
| public final void rule__Object__Group_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3124:1: ( ( ( rule__Object__NameAssignment_0_2 )? ) ) |
| // InternalSEW.g:3125:1: ( ( rule__Object__NameAssignment_0_2 )? ) |
| { |
| // InternalSEW.g:3125:1: ( ( rule__Object__NameAssignment_0_2 )? ) |
| // InternalSEW.g:3126:2: ( rule__Object__NameAssignment_0_2 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getNameAssignment_0_2()); |
| } |
| // InternalSEW.g:3127:2: ( rule__Object__NameAssignment_0_2 )? |
| int alt53=2; |
| int LA53_0 = input.LA(1); |
| |
| if ( (LA53_0==RULE_XIDENDIFIER||LA53_0==14||LA53_0==18||(LA53_0>=42 && LA53_0<=47)) ) { |
| alt53=1; |
| } |
| switch (alt53) { |
| case 1 : |
| // InternalSEW.g:3127:3: rule__Object__NameAssignment_0_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__NameAssignment_0_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getNameAssignment_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__3" |
| // InternalSEW.g:3135:1: rule__Object__Group_0__3 : rule__Object__Group_0__3__Impl rule__Object__Group_0__4 ; |
| public final void rule__Object__Group_0__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3139:1: ( rule__Object__Group_0__3__Impl rule__Object__Group_0__4 ) |
| // InternalSEW.g:3140:2: rule__Object__Group_0__3__Impl rule__Object__Group_0__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_5); |
| rule__Object__Group_0__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_0__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__3" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__3__Impl" |
| // InternalSEW.g:3147:1: rule__Object__Group_0__3__Impl : ( ( rule__Object__DescriptionAssignment_0_3 )? ) ; |
| public final void rule__Object__Group_0__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3151:1: ( ( ( rule__Object__DescriptionAssignment_0_3 )? ) ) |
| // InternalSEW.g:3152:1: ( ( rule__Object__DescriptionAssignment_0_3 )? ) |
| { |
| // InternalSEW.g:3152:1: ( ( rule__Object__DescriptionAssignment_0_3 )? ) |
| // InternalSEW.g:3153:2: ( rule__Object__DescriptionAssignment_0_3 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getDescriptionAssignment_0_3()); |
| } |
| // InternalSEW.g:3154:2: ( rule__Object__DescriptionAssignment_0_3 )? |
| int alt54=2; |
| int LA54_0 = input.LA(1); |
| |
| if ( (LA54_0==RULE_STRING) ) { |
| alt54=1; |
| } |
| switch (alt54) { |
| case 1 : |
| // InternalSEW.g:3154:3: rule__Object__DescriptionAssignment_0_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__DescriptionAssignment_0_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getDescriptionAssignment_0_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__3__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__4" |
| // InternalSEW.g:3162:1: rule__Object__Group_0__4 : rule__Object__Group_0__4__Impl rule__Object__Group_0__5 ; |
| public final void rule__Object__Group_0__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3166:1: ( rule__Object__Group_0__4__Impl rule__Object__Group_0__5 ) |
| // InternalSEW.g:3167:2: rule__Object__Group_0__4__Impl rule__Object__Group_0__5 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__Object__Group_0__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_0__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__4" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__4__Impl" |
| // InternalSEW.g:3174:1: rule__Object__Group_0__4__Impl : ( '{' ) ; |
| public final void rule__Object__Group_0__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3178:1: ( ( '{' ) ) |
| // InternalSEW.g:3179:1: ( '{' ) |
| { |
| // InternalSEW.g:3179:1: ( '{' ) |
| // InternalSEW.g:3180:2: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getLeftCurlyBracketKeyword_0_4()); |
| } |
| match(input,50,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getLeftCurlyBracketKeyword_0_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__4__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__5" |
| // InternalSEW.g:3189:1: rule__Object__Group_0__5 : rule__Object__Group_0__5__Impl rule__Object__Group_0__6 ; |
| public final void rule__Object__Group_0__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3193:1: ( rule__Object__Group_0__5__Impl rule__Object__Group_0__6 ) |
| // InternalSEW.g:3194:2: rule__Object__Group_0__5__Impl rule__Object__Group_0__6 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__Object__Group_0__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_0__6(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__5" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__5__Impl" |
| // InternalSEW.g:3201:1: rule__Object__Group_0__5__Impl : ( ( rule__Object__ElementAssignment_0_5 )* ) ; |
| public final void rule__Object__Group_0__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3205:1: ( ( ( rule__Object__ElementAssignment_0_5 )* ) ) |
| // InternalSEW.g:3206:1: ( ( rule__Object__ElementAssignment_0_5 )* ) |
| { |
| // InternalSEW.g:3206:1: ( ( rule__Object__ElementAssignment_0_5 )* ) |
| // InternalSEW.g:3207:2: ( rule__Object__ElementAssignment_0_5 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getElementAssignment_0_5()); |
| } |
| // InternalSEW.g:3208:2: ( rule__Object__ElementAssignment_0_5 )* |
| loop55: |
| do { |
| int alt55=2; |
| int LA55_0 = input.LA(1); |
| |
| if ( (LA55_0==RULE_XIDENDIFIER||LA55_0==14||LA55_0==18||(LA55_0>=42 && LA55_0<=47)) ) { |
| alt55=1; |
| } |
| |
| |
| switch (alt55) { |
| case 1 : |
| // InternalSEW.g:3208:3: rule__Object__ElementAssignment_0_5 |
| { |
| pushFollow(FollowSets000.FOLLOW_3); |
| rule__Object__ElementAssignment_0_5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop55; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getElementAssignment_0_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__5__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__6" |
| // InternalSEW.g:3216:1: rule__Object__Group_0__6 : rule__Object__Group_0__6__Impl ; |
| public final void rule__Object__Group_0__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3220:1: ( rule__Object__Group_0__6__Impl ) |
| // InternalSEW.g:3221:2: rule__Object__Group_0__6__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_0__6__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__6" |
| |
| |
| // $ANTLR start "rule__Object__Group_0__6__Impl" |
| // InternalSEW.g:3227:1: rule__Object__Group_0__6__Impl : ( '}' ) ; |
| public final void rule__Object__Group_0__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3231:1: ( ( '}' ) ) |
| // InternalSEW.g:3232:1: ( '}' ) |
| { |
| // InternalSEW.g:3232:1: ( '}' ) |
| // InternalSEW.g:3233:2: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getRightCurlyBracketKeyword_0_6()); |
| } |
| match(input,51,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getRightCurlyBracketKeyword_0_6()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_0__6__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__0" |
| // InternalSEW.g:3243:1: rule__Object__Group_1__0 : rule__Object__Group_1__0__Impl rule__Object__Group_1__1 ; |
| public final void rule__Object__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3247:1: ( rule__Object__Group_1__0__Impl rule__Object__Group_1__1 ) |
| // InternalSEW.g:3248:2: rule__Object__Group_1__0__Impl rule__Object__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__Object__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__0" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__0__Impl" |
| // InternalSEW.g:3255:1: rule__Object__Group_1__0__Impl : ( () ) ; |
| public final void rule__Object__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3259:1: ( ( () ) ) |
| // InternalSEW.g:3260:1: ( () ) |
| { |
| // InternalSEW.g:3260:1: ( () ) |
| // InternalSEW.g:3261:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getWObjectAction_1_0()); |
| } |
| // InternalSEW.g:3262:2: () |
| // InternalSEW.g:3262:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getWObjectAction_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__1" |
| // InternalSEW.g:3270:1: rule__Object__Group_1__1 : rule__Object__Group_1__1__Impl rule__Object__Group_1__2 ; |
| public final void rule__Object__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3274:1: ( rule__Object__Group_1__1__Impl rule__Object__Group_1__2 ) |
| // InternalSEW.g:3275:2: rule__Object__Group_1__1__Impl rule__Object__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_14); |
| rule__Object__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__1" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__1__Impl" |
| // InternalSEW.g:3282:1: rule__Object__Group_1__1__Impl : ( ( rule__Object__NameAssignment_1_1 ) ) ; |
| public final void rule__Object__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3286:1: ( ( ( rule__Object__NameAssignment_1_1 ) ) ) |
| // InternalSEW.g:3287:1: ( ( rule__Object__NameAssignment_1_1 ) ) |
| { |
| // InternalSEW.g:3287:1: ( ( rule__Object__NameAssignment_1_1 ) ) |
| // InternalSEW.g:3288:2: ( rule__Object__NameAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getNameAssignment_1_1()); |
| } |
| // InternalSEW.g:3289:2: ( rule__Object__NameAssignment_1_1 ) |
| // InternalSEW.g:3289:3: rule__Object__NameAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__NameAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getNameAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__2" |
| // InternalSEW.g:3297:1: rule__Object__Group_1__2 : rule__Object__Group_1__2__Impl rule__Object__Group_1__3 ; |
| public final void rule__Object__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3301:1: ( rule__Object__Group_1__2__Impl rule__Object__Group_1__3 ) |
| // InternalSEW.g:3302:2: rule__Object__Group_1__2__Impl rule__Object__Group_1__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_15); |
| rule__Object__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__2" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__2__Impl" |
| // InternalSEW.g:3309:1: rule__Object__Group_1__2__Impl : ( ( rule__Object__Alternatives_1_2 ) ) ; |
| public final void rule__Object__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3313:1: ( ( ( rule__Object__Alternatives_1_2 ) ) ) |
| // InternalSEW.g:3314:1: ( ( rule__Object__Alternatives_1_2 ) ) |
| { |
| // InternalSEW.g:3314:1: ( ( rule__Object__Alternatives_1_2 ) ) |
| // InternalSEW.g:3315:2: ( rule__Object__Alternatives_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getAlternatives_1_2()); |
| } |
| // InternalSEW.g:3316:2: ( rule__Object__Alternatives_1_2 ) |
| // InternalSEW.g:3316:3: rule__Object__Alternatives_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Alternatives_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getAlternatives_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__3" |
| // InternalSEW.g:3324:1: rule__Object__Group_1__3 : rule__Object__Group_1__3__Impl rule__Object__Group_1__4 ; |
| public final void rule__Object__Group_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3328:1: ( rule__Object__Group_1__3__Impl rule__Object__Group_1__4 ) |
| // InternalSEW.g:3329:2: rule__Object__Group_1__3__Impl rule__Object__Group_1__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_15); |
| rule__Object__Group_1__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_1__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__3" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__3__Impl" |
| // InternalSEW.g:3336:1: rule__Object__Group_1__3__Impl : ( ( rule__Object__Group_1_3__0 )? ) ; |
| public final void rule__Object__Group_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3340:1: ( ( ( rule__Object__Group_1_3__0 )? ) ) |
| // InternalSEW.g:3341:1: ( ( rule__Object__Group_1_3__0 )? ) |
| { |
| // InternalSEW.g:3341:1: ( ( rule__Object__Group_1_3__0 )? ) |
| // InternalSEW.g:3342:2: ( rule__Object__Group_1_3__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getGroup_1_3()); |
| } |
| // InternalSEW.g:3343:2: ( rule__Object__Group_1_3__0 )? |
| int alt56=2; |
| int LA56_0 = input.LA(1); |
| |
| if ( (LA56_0==RULE_XIDENDIFIER||LA56_0==14||LA56_0==18||(LA56_0>=42 && LA56_0<=47)) ) { |
| alt56=1; |
| } |
| switch (alt56) { |
| case 1 : |
| // InternalSEW.g:3343:3: rule__Object__Group_1_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_1_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getGroup_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__4" |
| // InternalSEW.g:3351:1: rule__Object__Group_1__4 : rule__Object__Group_1__4__Impl rule__Object__Group_1__5 ; |
| public final void rule__Object__Group_1__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3355:1: ( rule__Object__Group_1__4__Impl rule__Object__Group_1__5 ) |
| // InternalSEW.g:3356:2: rule__Object__Group_1__4__Impl rule__Object__Group_1__5 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__Object__Group_1__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_1__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__4" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__4__Impl" |
| // InternalSEW.g:3363:1: rule__Object__Group_1__4__Impl : ( '{' ) ; |
| public final void rule__Object__Group_1__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3367:1: ( ( '{' ) ) |
| // InternalSEW.g:3368:1: ( '{' ) |
| { |
| // InternalSEW.g:3368:1: ( '{' ) |
| // InternalSEW.g:3369:2: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getLeftCurlyBracketKeyword_1_4()); |
| } |
| match(input,50,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getLeftCurlyBracketKeyword_1_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__4__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__5" |
| // InternalSEW.g:3378:1: rule__Object__Group_1__5 : rule__Object__Group_1__5__Impl rule__Object__Group_1__6 ; |
| public final void rule__Object__Group_1__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3382:1: ( rule__Object__Group_1__5__Impl rule__Object__Group_1__6 ) |
| // InternalSEW.g:3383:2: rule__Object__Group_1__5__Impl rule__Object__Group_1__6 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__Object__Group_1__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_1__6(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__5" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__5__Impl" |
| // InternalSEW.g:3390:1: rule__Object__Group_1__5__Impl : ( ( rule__Object__ElementAssignment_1_5 )* ) ; |
| public final void rule__Object__Group_1__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3394:1: ( ( ( rule__Object__ElementAssignment_1_5 )* ) ) |
| // InternalSEW.g:3395:1: ( ( rule__Object__ElementAssignment_1_5 )* ) |
| { |
| // InternalSEW.g:3395:1: ( ( rule__Object__ElementAssignment_1_5 )* ) |
| // InternalSEW.g:3396:2: ( rule__Object__ElementAssignment_1_5 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getElementAssignment_1_5()); |
| } |
| // InternalSEW.g:3397:2: ( rule__Object__ElementAssignment_1_5 )* |
| loop57: |
| do { |
| int alt57=2; |
| int LA57_0 = input.LA(1); |
| |
| if ( (LA57_0==RULE_XIDENDIFIER||LA57_0==14||LA57_0==18||(LA57_0>=42 && LA57_0<=47)) ) { |
| alt57=1; |
| } |
| |
| |
| switch (alt57) { |
| case 1 : |
| // InternalSEW.g:3397:3: rule__Object__ElementAssignment_1_5 |
| { |
| pushFollow(FollowSets000.FOLLOW_3); |
| rule__Object__ElementAssignment_1_5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop57; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getElementAssignment_1_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__5__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__6" |
| // InternalSEW.g:3405:1: rule__Object__Group_1__6 : rule__Object__Group_1__6__Impl ; |
| public final void rule__Object__Group_1__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3409:1: ( rule__Object__Group_1__6__Impl ) |
| // InternalSEW.g:3410:2: rule__Object__Group_1__6__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_1__6__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__6" |
| |
| |
| // $ANTLR start "rule__Object__Group_1__6__Impl" |
| // InternalSEW.g:3416:1: rule__Object__Group_1__6__Impl : ( '}' ) ; |
| public final void rule__Object__Group_1__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3420:1: ( ( '}' ) ) |
| // InternalSEW.g:3421:1: ( '}' ) |
| { |
| // InternalSEW.g:3421:1: ( '}' ) |
| // InternalSEW.g:3422:2: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getRightCurlyBracketKeyword_1_6()); |
| } |
| match(input,51,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getRightCurlyBracketKeyword_1_6()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1__6__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_1_3__0" |
| // InternalSEW.g:3432:1: rule__Object__Group_1_3__0 : rule__Object__Group_1_3__0__Impl rule__Object__Group_1_3__1 ; |
| public final void rule__Object__Group_1_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3436:1: ( rule__Object__Group_1_3__0__Impl rule__Object__Group_1_3__1 ) |
| // InternalSEW.g:3437:2: rule__Object__Group_1_3__0__Impl rule__Object__Group_1_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_16); |
| rule__Object__Group_1_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_1_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1_3__0" |
| |
| |
| // $ANTLR start "rule__Object__Group_1_3__0__Impl" |
| // InternalSEW.g:3444:1: rule__Object__Group_1_3__0__Impl : ( ( rule__Object__TypeAssignment_1_3_0 ) ) ; |
| public final void rule__Object__Group_1_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3448:1: ( ( ( rule__Object__TypeAssignment_1_3_0 ) ) ) |
| // InternalSEW.g:3449:1: ( ( rule__Object__TypeAssignment_1_3_0 ) ) |
| { |
| // InternalSEW.g:3449:1: ( ( rule__Object__TypeAssignment_1_3_0 ) ) |
| // InternalSEW.g:3450:2: ( rule__Object__TypeAssignment_1_3_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getTypeAssignment_1_3_0()); |
| } |
| // InternalSEW.g:3451:2: ( rule__Object__TypeAssignment_1_3_0 ) |
| // InternalSEW.g:3451:3: rule__Object__TypeAssignment_1_3_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__TypeAssignment_1_3_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getTypeAssignment_1_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__Object__Group_1_3__1" |
| // InternalSEW.g:3459:1: rule__Object__Group_1_3__1 : rule__Object__Group_1_3__1__Impl ; |
| public final void rule__Object__Group_1_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3463:1: ( rule__Object__Group_1_3__1__Impl ) |
| // InternalSEW.g:3464:2: rule__Object__Group_1_3__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__Group_1_3__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1_3__1" |
| |
| |
| // $ANTLR start "rule__Object__Group_1_3__1__Impl" |
| // InternalSEW.g:3470:1: rule__Object__Group_1_3__1__Impl : ( ( rule__Object__DescriptionAssignment_1_3_1 )? ) ; |
| public final void rule__Object__Group_1_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3474:1: ( ( ( rule__Object__DescriptionAssignment_1_3_1 )? ) ) |
| // InternalSEW.g:3475:1: ( ( rule__Object__DescriptionAssignment_1_3_1 )? ) |
| { |
| // InternalSEW.g:3475:1: ( ( rule__Object__DescriptionAssignment_1_3_1 )? ) |
| // InternalSEW.g:3476:2: ( rule__Object__DescriptionAssignment_1_3_1 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getDescriptionAssignment_1_3_1()); |
| } |
| // InternalSEW.g:3477:2: ( rule__Object__DescriptionAssignment_1_3_1 )? |
| int alt58=2; |
| int LA58_0 = input.LA(1); |
| |
| if ( (LA58_0==RULE_STRING) ) { |
| alt58=1; |
| } |
| switch (alt58) { |
| case 1 : |
| // InternalSEW.g:3477:3: rule__Object__DescriptionAssignment_1_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__DescriptionAssignment_1_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getDescriptionAssignment_1_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__Group_1_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__Section__Group__0" |
| // InternalSEW.g:3486:1: rule__Section__Group__0 : rule__Section__Group__0__Impl rule__Section__Group__1 ; |
| public final void rule__Section__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3490:1: ( rule__Section__Group__0__Impl rule__Section__Group__1 ) |
| // InternalSEW.g:3491:2: rule__Section__Group__0__Impl rule__Section__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_17); |
| rule__Section__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group__0" |
| |
| |
| // $ANTLR start "rule__Section__Group__0__Impl" |
| // InternalSEW.g:3498:1: rule__Section__Group__0__Impl : ( ( rule__Section__NameAssignment_0 ) ) ; |
| public final void rule__Section__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3502:1: ( ( ( rule__Section__NameAssignment_0 ) ) ) |
| // InternalSEW.g:3503:1: ( ( rule__Section__NameAssignment_0 ) ) |
| { |
| // InternalSEW.g:3503:1: ( ( rule__Section__NameAssignment_0 ) ) |
| // InternalSEW.g:3504:2: ( rule__Section__NameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getNameAssignment_0()); |
| } |
| // InternalSEW.g:3505:2: ( rule__Section__NameAssignment_0 ) |
| // InternalSEW.g:3505:3: rule__Section__NameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__NameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__Section__Group__1" |
| // InternalSEW.g:3513:1: rule__Section__Group__1 : rule__Section__Group__1__Impl rule__Section__Group__2 ; |
| public final void rule__Section__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3517:1: ( rule__Section__Group__1__Impl rule__Section__Group__2 ) |
| // InternalSEW.g:3518:2: rule__Section__Group__1__Impl rule__Section__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_17); |
| rule__Section__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group__1" |
| |
| |
| // $ANTLR start "rule__Section__Group__1__Impl" |
| // InternalSEW.g:3525:1: rule__Section__Group__1__Impl : ( ( rule__Section__DescriptionAssignment_1 )? ) ; |
| public final void rule__Section__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3529:1: ( ( ( rule__Section__DescriptionAssignment_1 )? ) ) |
| // InternalSEW.g:3530:1: ( ( rule__Section__DescriptionAssignment_1 )? ) |
| { |
| // InternalSEW.g:3530:1: ( ( rule__Section__DescriptionAssignment_1 )? ) |
| // InternalSEW.g:3531:2: ( rule__Section__DescriptionAssignment_1 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getDescriptionAssignment_1()); |
| } |
| // InternalSEW.g:3532:2: ( rule__Section__DescriptionAssignment_1 )? |
| int alt59=2; |
| int LA59_0 = input.LA(1); |
| |
| if ( (LA59_0==RULE_STRING) ) { |
| alt59=1; |
| } |
| switch (alt59) { |
| case 1 : |
| // InternalSEW.g:3532:3: rule__Section__DescriptionAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__DescriptionAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getDescriptionAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Section__Group__2" |
| // InternalSEW.g:3540:1: rule__Section__Group__2 : rule__Section__Group__2__Impl ; |
| public final void rule__Section__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3544:1: ( rule__Section__Group__2__Impl ) |
| // InternalSEW.g:3545:2: rule__Section__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group__2" |
| |
| |
| // $ANTLR start "rule__Section__Group__2__Impl" |
| // InternalSEW.g:3551:1: rule__Section__Group__2__Impl : ( ( rule__Section__Alternatives_2 ) ) ; |
| public final void rule__Section__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3555:1: ( ( ( rule__Section__Alternatives_2 ) ) ) |
| // InternalSEW.g:3556:1: ( ( rule__Section__Alternatives_2 ) ) |
| { |
| // InternalSEW.g:3556:1: ( ( rule__Section__Alternatives_2 ) ) |
| // InternalSEW.g:3557:2: ( rule__Section__Alternatives_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getAlternatives_2()); |
| } |
| // InternalSEW.g:3558:2: ( rule__Section__Alternatives_2 ) |
| // InternalSEW.g:3558:3: rule__Section__Alternatives_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Alternatives_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getAlternatives_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__Section__Group_2_0__0" |
| // InternalSEW.g:3567:1: rule__Section__Group_2_0__0 : rule__Section__Group_2_0__0__Impl rule__Section__Group_2_0__1 ; |
| public final void rule__Section__Group_2_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3571:1: ( rule__Section__Group_2_0__0__Impl rule__Section__Group_2_0__1 ) |
| // InternalSEW.g:3572:2: rule__Section__Group_2_0__0__Impl rule__Section__Group_2_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__Section__Group_2_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Group_2_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group_2_0__0" |
| |
| |
| // $ANTLR start "rule__Section__Group_2_0__0__Impl" |
| // InternalSEW.g:3579:1: rule__Section__Group_2_0__0__Impl : ( '[' ) ; |
| public final void rule__Section__Group_2_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3583:1: ( ( '[' ) ) |
| // InternalSEW.g:3584:1: ( '[' ) |
| { |
| // InternalSEW.g:3584:1: ( '[' ) |
| // InternalSEW.g:3585:2: '[' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getLeftSquareBracketKeyword_2_0_0()); |
| } |
| match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getLeftSquareBracketKeyword_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group_2_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__Section__Group_2_0__1" |
| // InternalSEW.g:3594:1: rule__Section__Group_2_0__1 : rule__Section__Group_2_0__1__Impl rule__Section__Group_2_0__2 ; |
| public final void rule__Section__Group_2_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3598:1: ( rule__Section__Group_2_0__1__Impl rule__Section__Group_2_0__2 ) |
| // InternalSEW.g:3599:2: rule__Section__Group_2_0__1__Impl rule__Section__Group_2_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__Section__Group_2_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Group_2_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group_2_0__1" |
| |
| |
| // $ANTLR start "rule__Section__Group_2_0__1__Impl" |
| // InternalSEW.g:3606:1: rule__Section__Group_2_0__1__Impl : ( ( rule__Section__ElementAssignment_2_0_1 )* ) ; |
| public final void rule__Section__Group_2_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3610:1: ( ( ( rule__Section__ElementAssignment_2_0_1 )* ) ) |
| // InternalSEW.g:3611:1: ( ( rule__Section__ElementAssignment_2_0_1 )* ) |
| { |
| // InternalSEW.g:3611:1: ( ( rule__Section__ElementAssignment_2_0_1 )* ) |
| // InternalSEW.g:3612:2: ( rule__Section__ElementAssignment_2_0_1 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getElementAssignment_2_0_1()); |
| } |
| // InternalSEW.g:3613:2: ( rule__Section__ElementAssignment_2_0_1 )* |
| loop60: |
| do { |
| int alt60=2; |
| int LA60_0 = input.LA(1); |
| |
| if ( (LA60_0==RULE_XIDENDIFIER||LA60_0==14||LA60_0==18||(LA60_0>=42 && LA60_0<=47)) ) { |
| alt60=1; |
| } |
| |
| |
| switch (alt60) { |
| case 1 : |
| // InternalSEW.g:3613:3: rule__Section__ElementAssignment_2_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_3); |
| rule__Section__ElementAssignment_2_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop60; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getElementAssignment_2_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group_2_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__Section__Group_2_0__2" |
| // InternalSEW.g:3621:1: rule__Section__Group_2_0__2 : rule__Section__Group_2_0__2__Impl ; |
| public final void rule__Section__Group_2_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3625:1: ( rule__Section__Group_2_0__2__Impl ) |
| // InternalSEW.g:3626:2: rule__Section__Group_2_0__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Group_2_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group_2_0__2" |
| |
| |
| // $ANTLR start "rule__Section__Group_2_0__2__Impl" |
| // InternalSEW.g:3632:1: rule__Section__Group_2_0__2__Impl : ( ']' ) ; |
| public final void rule__Section__Group_2_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3636:1: ( ( ']' ) ) |
| // InternalSEW.g:3637:1: ( ']' ) |
| { |
| // InternalSEW.g:3637:1: ( ']' ) |
| // InternalSEW.g:3638:2: ']' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getRightSquareBracketKeyword_2_0_2()); |
| } |
| match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getRightSquareBracketKeyword_2_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group_2_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__Section__Group_2_1__0" |
| // InternalSEW.g:3648:1: rule__Section__Group_2_1__0 : rule__Section__Group_2_1__0__Impl rule__Section__Group_2_1__1 ; |
| public final void rule__Section__Group_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3652:1: ( rule__Section__Group_2_1__0__Impl rule__Section__Group_2_1__1 ) |
| // InternalSEW.g:3653:2: rule__Section__Group_2_1__0__Impl rule__Section__Group_2_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__Section__Group_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Group_2_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group_2_1__0" |
| |
| |
| // $ANTLR start "rule__Section__Group_2_1__0__Impl" |
| // InternalSEW.g:3660:1: rule__Section__Group_2_1__0__Impl : ( ':' ) ; |
| public final void rule__Section__Group_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3664:1: ( ( ':' ) ) |
| // InternalSEW.g:3665:1: ( ':' ) |
| { |
| // InternalSEW.g:3665:1: ( ':' ) |
| // InternalSEW.g:3666:2: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getColonKeyword_2_1_0()); |
| } |
| match(input,57,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getColonKeyword_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__Section__Group_2_1__1" |
| // InternalSEW.g:3675:1: rule__Section__Group_2_1__1 : rule__Section__Group_2_1__1__Impl ; |
| public final void rule__Section__Group_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3679:1: ( rule__Section__Group_2_1__1__Impl ) |
| // InternalSEW.g:3680:2: rule__Section__Group_2_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__Group_2_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group_2_1__1" |
| |
| |
| // $ANTLR start "rule__Section__Group_2_1__1__Impl" |
| // InternalSEW.g:3686:1: rule__Section__Group_2_1__1__Impl : ( ( rule__Section__ElementAssignment_2_1_1 )* ) ; |
| public final void rule__Section__Group_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3690:1: ( ( ( rule__Section__ElementAssignment_2_1_1 )* ) ) |
| // InternalSEW.g:3691:1: ( ( rule__Section__ElementAssignment_2_1_1 )* ) |
| { |
| // InternalSEW.g:3691:1: ( ( rule__Section__ElementAssignment_2_1_1 )* ) |
| // InternalSEW.g:3692:2: ( rule__Section__ElementAssignment_2_1_1 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getElementAssignment_2_1_1()); |
| } |
| // InternalSEW.g:3693:2: ( rule__Section__ElementAssignment_2_1_1 )* |
| loop61: |
| do { |
| int alt61=2; |
| alt61 = dfa61.predict(input); |
| switch (alt61) { |
| case 1 : |
| // InternalSEW.g:3693:3: rule__Section__ElementAssignment_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_3); |
| rule__Section__ElementAssignment_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop61; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getElementAssignment_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__Group_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__Attribute__Group__0" |
| // InternalSEW.g:3702:1: rule__Attribute__Group__0 : rule__Attribute__Group__0__Impl rule__Attribute__Group__1 ; |
| public final void rule__Attribute__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3706:1: ( rule__Attribute__Group__0__Impl rule__Attribute__Group__1 ) |
| // InternalSEW.g:3707:2: rule__Attribute__Group__0__Impl rule__Attribute__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__Attribute__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Attribute__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__Group__0" |
| |
| |
| // $ANTLR start "rule__Attribute__Group__0__Impl" |
| // InternalSEW.g:3714:1: rule__Attribute__Group__0__Impl : ( () ) ; |
| public final void rule__Attribute__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3718:1: ( ( () ) ) |
| // InternalSEW.g:3719:1: ( () ) |
| { |
| // InternalSEW.g:3719:1: ( () ) |
| // InternalSEW.g:3720:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAttributeAccess().getWAttributeAction_0()); |
| } |
| // InternalSEW.g:3721:2: () |
| // InternalSEW.g:3721:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAttributeAccess().getWAttributeAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__Attribute__Group__1" |
| // InternalSEW.g:3729:1: rule__Attribute__Group__1 : rule__Attribute__Group__1__Impl rule__Attribute__Group__2 ; |
| public final void rule__Attribute__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3733:1: ( rule__Attribute__Group__1__Impl rule__Attribute__Group__2 ) |
| // InternalSEW.g:3734:2: rule__Attribute__Group__1__Impl rule__Attribute__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_19); |
| rule__Attribute__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Attribute__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__Group__1" |
| |
| |
| // $ANTLR start "rule__Attribute__Group__1__Impl" |
| // InternalSEW.g:3741:1: rule__Attribute__Group__1__Impl : ( ( rule__Attribute__NameAssignment_1 ) ) ; |
| public final void rule__Attribute__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3745:1: ( ( ( rule__Attribute__NameAssignment_1 ) ) ) |
| // InternalSEW.g:3746:1: ( ( rule__Attribute__NameAssignment_1 ) ) |
| { |
| // InternalSEW.g:3746:1: ( ( rule__Attribute__NameAssignment_1 ) ) |
| // InternalSEW.g:3747:2: ( rule__Attribute__NameAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAttributeAccess().getNameAssignment_1()); |
| } |
| // InternalSEW.g:3748:2: ( rule__Attribute__NameAssignment_1 ) |
| // InternalSEW.g:3748:3: rule__Attribute__NameAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Attribute__NameAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAttributeAccess().getNameAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Attribute__Group__2" |
| // InternalSEW.g:3756:1: rule__Attribute__Group__2 : rule__Attribute__Group__2__Impl rule__Attribute__Group__3 ; |
| public final void rule__Attribute__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3760:1: ( rule__Attribute__Group__2__Impl rule__Attribute__Group__3 ) |
| // InternalSEW.g:3761:2: rule__Attribute__Group__2__Impl rule__Attribute__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__Attribute__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Attribute__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__Group__2" |
| |
| |
| // $ANTLR start "rule__Attribute__Group__2__Impl" |
| // InternalSEW.g:3768:1: rule__Attribute__Group__2__Impl : ( '=' ) ; |
| public final void rule__Attribute__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3772:1: ( ( '=' ) ) |
| // InternalSEW.g:3773:1: ( '=' ) |
| { |
| // InternalSEW.g:3773:1: ( '=' ) |
| // InternalSEW.g:3774:2: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAttributeAccess().getEqualsSignKeyword_2()); |
| } |
| match(input,58,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAttributeAccess().getEqualsSignKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__Attribute__Group__3" |
| // InternalSEW.g:3783:1: rule__Attribute__Group__3 : rule__Attribute__Group__3__Impl rule__Attribute__Group__4 ; |
| public final void rule__Attribute__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3787:1: ( rule__Attribute__Group__3__Impl rule__Attribute__Group__4 ) |
| // InternalSEW.g:3788:2: rule__Attribute__Group__3__Impl rule__Attribute__Group__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_21); |
| rule__Attribute__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Attribute__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__Group__3" |
| |
| |
| // $ANTLR start "rule__Attribute__Group__3__Impl" |
| // InternalSEW.g:3795:1: rule__Attribute__Group__3__Impl : ( ( rule__Attribute__ValueAssignment_3 ) ) ; |
| public final void rule__Attribute__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3799:1: ( ( ( rule__Attribute__ValueAssignment_3 ) ) ) |
| // InternalSEW.g:3800:1: ( ( rule__Attribute__ValueAssignment_3 ) ) |
| { |
| // InternalSEW.g:3800:1: ( ( rule__Attribute__ValueAssignment_3 ) ) |
| // InternalSEW.g:3801:2: ( rule__Attribute__ValueAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAttributeAccess().getValueAssignment_3()); |
| } |
| // InternalSEW.g:3802:2: ( rule__Attribute__ValueAssignment_3 ) |
| // InternalSEW.g:3802:3: rule__Attribute__ValueAssignment_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Attribute__ValueAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAttributeAccess().getValueAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__Attribute__Group__4" |
| // InternalSEW.g:3810:1: rule__Attribute__Group__4 : rule__Attribute__Group__4__Impl ; |
| public final void rule__Attribute__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3814:1: ( rule__Attribute__Group__4__Impl ) |
| // InternalSEW.g:3815:2: rule__Attribute__Group__4__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Attribute__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__Group__4" |
| |
| |
| // $ANTLR start "rule__Attribute__Group__4__Impl" |
| // InternalSEW.g:3821:1: rule__Attribute__Group__4__Impl : ( ( ';' )? ) ; |
| public final void rule__Attribute__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3825:1: ( ( ( ';' )? ) ) |
| // InternalSEW.g:3826:1: ( ( ';' )? ) |
| { |
| // InternalSEW.g:3826:1: ( ( ';' )? ) |
| // InternalSEW.g:3827:2: ( ';' )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAttributeAccess().getSemicolonKeyword_4()); |
| } |
| // InternalSEW.g:3828:2: ( ';' )? |
| int alt62=2; |
| int LA62_0 = input.LA(1); |
| |
| if ( (LA62_0==59) ) { |
| alt62=1; |
| } |
| switch (alt62) { |
| case 1 : |
| // InternalSEW.g:3828:3: ';' |
| { |
| match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAttributeAccess().getSemicolonKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group__0" |
| // InternalSEW.g:3837:1: rule__ConditionalExpression__Group__0 : rule__ConditionalExpression__Group__0__Impl rule__ConditionalExpression__Group__1 ; |
| public final void rule__ConditionalExpression__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3841:1: ( rule__ConditionalExpression__Group__0__Impl rule__ConditionalExpression__Group__1 ) |
| // InternalSEW.g:3842:2: rule__ConditionalExpression__Group__0__Impl rule__ConditionalExpression__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_22); |
| rule__ConditionalExpression__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group__0" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group__0__Impl" |
| // InternalSEW.g:3849:1: rule__ConditionalExpression__Group__0__Impl : ( ruleconditionalOrExpression ) ; |
| public final void rule__ConditionalExpression__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3853:1: ( ( ruleconditionalOrExpression ) ) |
| // InternalSEW.g:3854:1: ( ruleconditionalOrExpression ) |
| { |
| // InternalSEW.g:3854:1: ( ruleconditionalOrExpression ) |
| // InternalSEW.g:3855:2: ruleconditionalOrExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getConditionalOrExpressionParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleconditionalOrExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getConditionalOrExpressionParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group__1" |
| // InternalSEW.g:3864:1: rule__ConditionalExpression__Group__1 : rule__ConditionalExpression__Group__1__Impl ; |
| public final void rule__ConditionalExpression__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3868:1: ( rule__ConditionalExpression__Group__1__Impl ) |
| // InternalSEW.g:3869:2: rule__ConditionalExpression__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group__1" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group__1__Impl" |
| // InternalSEW.g:3875:1: rule__ConditionalExpression__Group__1__Impl : ( ( rule__ConditionalExpression__Group_1__0 )? ) ; |
| public final void rule__ConditionalExpression__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3879:1: ( ( ( rule__ConditionalExpression__Group_1__0 )? ) ) |
| // InternalSEW.g:3880:1: ( ( rule__ConditionalExpression__Group_1__0 )? ) |
| { |
| // InternalSEW.g:3880:1: ( ( rule__ConditionalExpression__Group_1__0 )? ) |
| // InternalSEW.g:3881:2: ( rule__ConditionalExpression__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getGroup_1()); |
| } |
| // InternalSEW.g:3882:2: ( rule__ConditionalExpression__Group_1__0 )? |
| int alt63=2; |
| int LA63_0 = input.LA(1); |
| |
| if ( (LA63_0==73) ) { |
| alt63=1; |
| } |
| switch (alt63) { |
| case 1 : |
| // InternalSEW.g:3882:3: rule__ConditionalExpression__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group_1__0" |
| // InternalSEW.g:3891:1: rule__ConditionalExpression__Group_1__0 : rule__ConditionalExpression__Group_1__0__Impl rule__ConditionalExpression__Group_1__1 ; |
| public final void rule__ConditionalExpression__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3895:1: ( rule__ConditionalExpression__Group_1__0__Impl rule__ConditionalExpression__Group_1__1 ) |
| // InternalSEW.g:3896:2: rule__ConditionalExpression__Group_1__0__Impl rule__ConditionalExpression__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_22); |
| rule__ConditionalExpression__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group_1__0" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group_1__0__Impl" |
| // InternalSEW.g:3903:1: rule__ConditionalExpression__Group_1__0__Impl : ( () ) ; |
| public final void rule__ConditionalExpression__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3907:1: ( ( () ) ) |
| // InternalSEW.g:3908:1: ( () ) |
| { |
| // InternalSEW.g:3908:1: ( () ) |
| // InternalSEW.g:3909:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| // InternalSEW.g:3910:2: () |
| // InternalSEW.g:3910:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group_1__1" |
| // InternalSEW.g:3918:1: rule__ConditionalExpression__Group_1__1 : rule__ConditionalExpression__Group_1__1__Impl rule__ConditionalExpression__Group_1__2 ; |
| public final void rule__ConditionalExpression__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3922:1: ( rule__ConditionalExpression__Group_1__1__Impl rule__ConditionalExpression__Group_1__2 ) |
| // InternalSEW.g:3923:2: rule__ConditionalExpression__Group_1__1__Impl rule__ConditionalExpression__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__ConditionalExpression__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group_1__1" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group_1__1__Impl" |
| // InternalSEW.g:3930:1: rule__ConditionalExpression__Group_1__1__Impl : ( ( rule__ConditionalExpression__OperatorAssignment_1_1 ) ) ; |
| public final void rule__ConditionalExpression__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3934:1: ( ( ( rule__ConditionalExpression__OperatorAssignment_1_1 ) ) ) |
| // InternalSEW.g:3935:1: ( ( rule__ConditionalExpression__OperatorAssignment_1_1 ) ) |
| { |
| // InternalSEW.g:3935:1: ( ( rule__ConditionalExpression__OperatorAssignment_1_1 ) ) |
| // InternalSEW.g:3936:2: ( rule__ConditionalExpression__OperatorAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| // InternalSEW.g:3937:2: ( rule__ConditionalExpression__OperatorAssignment_1_1 ) |
| // InternalSEW.g:3937:3: rule__ConditionalExpression__OperatorAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__OperatorAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group_1__2" |
| // InternalSEW.g:3945:1: rule__ConditionalExpression__Group_1__2 : rule__ConditionalExpression__Group_1__2__Impl rule__ConditionalExpression__Group_1__3 ; |
| public final void rule__ConditionalExpression__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3949:1: ( rule__ConditionalExpression__Group_1__2__Impl rule__ConditionalExpression__Group_1__3 ) |
| // InternalSEW.g:3950:2: rule__ConditionalExpression__Group_1__2__Impl rule__ConditionalExpression__Group_1__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_23); |
| rule__ConditionalExpression__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__Group_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group_1__2" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group_1__2__Impl" |
| // InternalSEW.g:3957:1: rule__ConditionalExpression__Group_1__2__Impl : ( ( rule__ConditionalExpression__OperandAssignment_1_2 ) ) ; |
| public final void rule__ConditionalExpression__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3961:1: ( ( ( rule__ConditionalExpression__OperandAssignment_1_2 ) ) ) |
| // InternalSEW.g:3962:1: ( ( rule__ConditionalExpression__OperandAssignment_1_2 ) ) |
| { |
| // InternalSEW.g:3962:1: ( ( rule__ConditionalExpression__OperandAssignment_1_2 ) ) |
| // InternalSEW.g:3963:2: ( rule__ConditionalExpression__OperandAssignment_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getOperandAssignment_1_2()); |
| } |
| // InternalSEW.g:3964:2: ( rule__ConditionalExpression__OperandAssignment_1_2 ) |
| // InternalSEW.g:3964:3: rule__ConditionalExpression__OperandAssignment_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__OperandAssignment_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getOperandAssignment_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group_1__3" |
| // InternalSEW.g:3972:1: rule__ConditionalExpression__Group_1__3 : rule__ConditionalExpression__Group_1__3__Impl rule__ConditionalExpression__Group_1__4 ; |
| public final void rule__ConditionalExpression__Group_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3976:1: ( rule__ConditionalExpression__Group_1__3__Impl rule__ConditionalExpression__Group_1__4 ) |
| // InternalSEW.g:3977:2: rule__ConditionalExpression__Group_1__3__Impl rule__ConditionalExpression__Group_1__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__ConditionalExpression__Group_1__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__Group_1__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group_1__3" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group_1__3__Impl" |
| // InternalSEW.g:3984:1: rule__ConditionalExpression__Group_1__3__Impl : ( ':' ) ; |
| public final void rule__ConditionalExpression__Group_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:3988:1: ( ( ':' ) ) |
| // InternalSEW.g:3989:1: ( ':' ) |
| { |
| // InternalSEW.g:3989:1: ( ':' ) |
| // InternalSEW.g:3990:2: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getColonKeyword_1_3()); |
| } |
| match(input,57,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getColonKeyword_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group_1__4" |
| // InternalSEW.g:3999:1: rule__ConditionalExpression__Group_1__4 : rule__ConditionalExpression__Group_1__4__Impl ; |
| public final void rule__ConditionalExpression__Group_1__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4003:1: ( rule__ConditionalExpression__Group_1__4__Impl ) |
| // InternalSEW.g:4004:2: rule__ConditionalExpression__Group_1__4__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__Group_1__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group_1__4" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__Group_1__4__Impl" |
| // InternalSEW.g:4010:1: rule__ConditionalExpression__Group_1__4__Impl : ( ( rule__ConditionalExpression__OperandAssignment_1_4 ) ) ; |
| public final void rule__ConditionalExpression__Group_1__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4014:1: ( ( ( rule__ConditionalExpression__OperandAssignment_1_4 ) ) ) |
| // InternalSEW.g:4015:1: ( ( rule__ConditionalExpression__OperandAssignment_1_4 ) ) |
| { |
| // InternalSEW.g:4015:1: ( ( rule__ConditionalExpression__OperandAssignment_1_4 ) ) |
| // InternalSEW.g:4016:2: ( rule__ConditionalExpression__OperandAssignment_1_4 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getOperandAssignment_1_4()); |
| } |
| // InternalSEW.g:4017:2: ( rule__ConditionalExpression__OperandAssignment_1_4 ) |
| // InternalSEW.g:4017:3: rule__ConditionalExpression__OperandAssignment_1_4 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalExpression__OperandAssignment_1_4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getOperandAssignment_1_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__Group_1__4__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group__0" |
| // InternalSEW.g:4026:1: rule__ConditionalOrExpression__Group__0 : rule__ConditionalOrExpression__Group__0__Impl rule__ConditionalOrExpression__Group__1 ; |
| public final void rule__ConditionalOrExpression__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4030:1: ( rule__ConditionalOrExpression__Group__0__Impl rule__ConditionalOrExpression__Group__1 ) |
| // InternalSEW.g:4031:2: rule__ConditionalOrExpression__Group__0__Impl rule__ConditionalOrExpression__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_24); |
| rule__ConditionalOrExpression__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group__0" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group__0__Impl" |
| // InternalSEW.g:4038:1: rule__ConditionalOrExpression__Group__0__Impl : ( ruleconditionalAndExpression ) ; |
| public final void rule__ConditionalOrExpression__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4042:1: ( ( ruleconditionalAndExpression ) ) |
| // InternalSEW.g:4043:1: ( ruleconditionalAndExpression ) |
| { |
| // InternalSEW.g:4043:1: ( ruleconditionalAndExpression ) |
| // InternalSEW.g:4044:2: ruleconditionalAndExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getConditionalAndExpressionParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleconditionalAndExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getConditionalAndExpressionParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group__1" |
| // InternalSEW.g:4053:1: rule__ConditionalOrExpression__Group__1 : rule__ConditionalOrExpression__Group__1__Impl ; |
| public final void rule__ConditionalOrExpression__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4057:1: ( rule__ConditionalOrExpression__Group__1__Impl ) |
| // InternalSEW.g:4058:2: rule__ConditionalOrExpression__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group__1" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group__1__Impl" |
| // InternalSEW.g:4064:1: rule__ConditionalOrExpression__Group__1__Impl : ( ( rule__ConditionalOrExpression__Group_1__0 )? ) ; |
| public final void rule__ConditionalOrExpression__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4068:1: ( ( ( rule__ConditionalOrExpression__Group_1__0 )? ) ) |
| // InternalSEW.g:4069:1: ( ( rule__ConditionalOrExpression__Group_1__0 )? ) |
| { |
| // InternalSEW.g:4069:1: ( ( rule__ConditionalOrExpression__Group_1__0 )? ) |
| // InternalSEW.g:4070:2: ( rule__ConditionalOrExpression__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getGroup_1()); |
| } |
| // InternalSEW.g:4071:2: ( rule__ConditionalOrExpression__Group_1__0 )? |
| int alt64=2; |
| int LA64_0 = input.LA(1); |
| |
| if ( ((LA64_0>=23 && LA64_0<=24)) ) { |
| alt64=1; |
| } |
| switch (alt64) { |
| case 1 : |
| // InternalSEW.g:4071:3: rule__ConditionalOrExpression__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1__0" |
| // InternalSEW.g:4080:1: rule__ConditionalOrExpression__Group_1__0 : rule__ConditionalOrExpression__Group_1__0__Impl rule__ConditionalOrExpression__Group_1__1 ; |
| public final void rule__ConditionalOrExpression__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4084:1: ( rule__ConditionalOrExpression__Group_1__0__Impl rule__ConditionalOrExpression__Group_1__1 ) |
| // InternalSEW.g:4085:2: rule__ConditionalOrExpression__Group_1__0__Impl rule__ConditionalOrExpression__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_24); |
| rule__ConditionalOrExpression__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1__0" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1__0__Impl" |
| // InternalSEW.g:4092:1: rule__ConditionalOrExpression__Group_1__0__Impl : ( () ) ; |
| public final void rule__ConditionalOrExpression__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4096:1: ( ( () ) ) |
| // InternalSEW.g:4097:1: ( () ) |
| { |
| // InternalSEW.g:4097:1: ( () ) |
| // InternalSEW.g:4098:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| // InternalSEW.g:4099:2: () |
| // InternalSEW.g:4099:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1__1" |
| // InternalSEW.g:4107:1: rule__ConditionalOrExpression__Group_1__1 : rule__ConditionalOrExpression__Group_1__1__Impl rule__ConditionalOrExpression__Group_1__2 ; |
| public final void rule__ConditionalOrExpression__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4111:1: ( rule__ConditionalOrExpression__Group_1__1__Impl rule__ConditionalOrExpression__Group_1__2 ) |
| // InternalSEW.g:4112:2: rule__ConditionalOrExpression__Group_1__1__Impl rule__ConditionalOrExpression__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__ConditionalOrExpression__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1__1" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1__1__Impl" |
| // InternalSEW.g:4119:1: rule__ConditionalOrExpression__Group_1__1__Impl : ( ( rule__ConditionalOrExpression__OperatorAssignment_1_1 ) ) ; |
| public final void rule__ConditionalOrExpression__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4123:1: ( ( ( rule__ConditionalOrExpression__OperatorAssignment_1_1 ) ) ) |
| // InternalSEW.g:4124:1: ( ( rule__ConditionalOrExpression__OperatorAssignment_1_1 ) ) |
| { |
| // InternalSEW.g:4124:1: ( ( rule__ConditionalOrExpression__OperatorAssignment_1_1 ) ) |
| // InternalSEW.g:4125:2: ( rule__ConditionalOrExpression__OperatorAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| // InternalSEW.g:4126:2: ( rule__ConditionalOrExpression__OperatorAssignment_1_1 ) |
| // InternalSEW.g:4126:3: rule__ConditionalOrExpression__OperatorAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__OperatorAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1__2" |
| // InternalSEW.g:4134:1: rule__ConditionalOrExpression__Group_1__2 : rule__ConditionalOrExpression__Group_1__2__Impl rule__ConditionalOrExpression__Group_1__3 ; |
| public final void rule__ConditionalOrExpression__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4138:1: ( rule__ConditionalOrExpression__Group_1__2__Impl rule__ConditionalOrExpression__Group_1__3 ) |
| // InternalSEW.g:4139:2: rule__ConditionalOrExpression__Group_1__2__Impl rule__ConditionalOrExpression__Group_1__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_24); |
| rule__ConditionalOrExpression__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__Group_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1__2" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1__2__Impl" |
| // InternalSEW.g:4146:1: rule__ConditionalOrExpression__Group_1__2__Impl : ( ( rule__ConditionalOrExpression__OperandAssignment_1_2 ) ) ; |
| public final void rule__ConditionalOrExpression__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4150:1: ( ( ( rule__ConditionalOrExpression__OperandAssignment_1_2 ) ) ) |
| // InternalSEW.g:4151:1: ( ( rule__ConditionalOrExpression__OperandAssignment_1_2 ) ) |
| { |
| // InternalSEW.g:4151:1: ( ( rule__ConditionalOrExpression__OperandAssignment_1_2 ) ) |
| // InternalSEW.g:4152:2: ( rule__ConditionalOrExpression__OperandAssignment_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getOperandAssignment_1_2()); |
| } |
| // InternalSEW.g:4153:2: ( rule__ConditionalOrExpression__OperandAssignment_1_2 ) |
| // InternalSEW.g:4153:3: rule__ConditionalOrExpression__OperandAssignment_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__OperandAssignment_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getOperandAssignment_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1__3" |
| // InternalSEW.g:4161:1: rule__ConditionalOrExpression__Group_1__3 : rule__ConditionalOrExpression__Group_1__3__Impl ; |
| public final void rule__ConditionalOrExpression__Group_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4165:1: ( rule__ConditionalOrExpression__Group_1__3__Impl ) |
| // InternalSEW.g:4166:2: rule__ConditionalOrExpression__Group_1__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__Group_1__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1__3" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1__3__Impl" |
| // InternalSEW.g:4172:1: rule__ConditionalOrExpression__Group_1__3__Impl : ( ( rule__ConditionalOrExpression__Group_1_3__0 )* ) ; |
| public final void rule__ConditionalOrExpression__Group_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4176:1: ( ( ( rule__ConditionalOrExpression__Group_1_3__0 )* ) ) |
| // InternalSEW.g:4177:1: ( ( rule__ConditionalOrExpression__Group_1_3__0 )* ) |
| { |
| // InternalSEW.g:4177:1: ( ( rule__ConditionalOrExpression__Group_1_3__0 )* ) |
| // InternalSEW.g:4178:2: ( rule__ConditionalOrExpression__Group_1_3__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getGroup_1_3()); |
| } |
| // InternalSEW.g:4179:2: ( rule__ConditionalOrExpression__Group_1_3__0 )* |
| loop65: |
| do { |
| int alt65=2; |
| int LA65_0 = input.LA(1); |
| |
| if ( ((LA65_0>=23 && LA65_0<=24)) ) { |
| alt65=1; |
| } |
| |
| |
| switch (alt65) { |
| case 1 : |
| // InternalSEW.g:4179:3: rule__ConditionalOrExpression__Group_1_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_26); |
| rule__ConditionalOrExpression__Group_1_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop65; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getGroup_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1_3__0" |
| // InternalSEW.g:4188:1: rule__ConditionalOrExpression__Group_1_3__0 : rule__ConditionalOrExpression__Group_1_3__0__Impl rule__ConditionalOrExpression__Group_1_3__1 ; |
| public final void rule__ConditionalOrExpression__Group_1_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4192:1: ( rule__ConditionalOrExpression__Group_1_3__0__Impl rule__ConditionalOrExpression__Group_1_3__1 ) |
| // InternalSEW.g:4193:2: rule__ConditionalOrExpression__Group_1_3__0__Impl rule__ConditionalOrExpression__Group_1_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__ConditionalOrExpression__Group_1_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__Group_1_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1_3__0" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1_3__0__Impl" |
| // InternalSEW.g:4200:1: rule__ConditionalOrExpression__Group_1_3__0__Impl : ( ( rule__ConditionalOrExpression__Alternatives_1_3_0 ) ) ; |
| public final void rule__ConditionalOrExpression__Group_1_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4204:1: ( ( ( rule__ConditionalOrExpression__Alternatives_1_3_0 ) ) ) |
| // InternalSEW.g:4205:1: ( ( rule__ConditionalOrExpression__Alternatives_1_3_0 ) ) |
| { |
| // InternalSEW.g:4205:1: ( ( rule__ConditionalOrExpression__Alternatives_1_3_0 ) ) |
| // InternalSEW.g:4206:2: ( rule__ConditionalOrExpression__Alternatives_1_3_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getAlternatives_1_3_0()); |
| } |
| // InternalSEW.g:4207:2: ( rule__ConditionalOrExpression__Alternatives_1_3_0 ) |
| // InternalSEW.g:4207:3: rule__ConditionalOrExpression__Alternatives_1_3_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__Alternatives_1_3_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getAlternatives_1_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1_3__1" |
| // InternalSEW.g:4215:1: rule__ConditionalOrExpression__Group_1_3__1 : rule__ConditionalOrExpression__Group_1_3__1__Impl ; |
| public final void rule__ConditionalOrExpression__Group_1_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4219:1: ( rule__ConditionalOrExpression__Group_1_3__1__Impl ) |
| // InternalSEW.g:4220:2: rule__ConditionalOrExpression__Group_1_3__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__Group_1_3__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1_3__1" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__Group_1_3__1__Impl" |
| // InternalSEW.g:4226:1: rule__ConditionalOrExpression__Group_1_3__1__Impl : ( ( rule__ConditionalOrExpression__OperandAssignment_1_3_1 ) ) ; |
| public final void rule__ConditionalOrExpression__Group_1_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4230:1: ( ( ( rule__ConditionalOrExpression__OperandAssignment_1_3_1 ) ) ) |
| // InternalSEW.g:4231:1: ( ( rule__ConditionalOrExpression__OperandAssignment_1_3_1 ) ) |
| { |
| // InternalSEW.g:4231:1: ( ( rule__ConditionalOrExpression__OperandAssignment_1_3_1 ) ) |
| // InternalSEW.g:4232:2: ( rule__ConditionalOrExpression__OperandAssignment_1_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getOperandAssignment_1_3_1()); |
| } |
| // InternalSEW.g:4233:2: ( rule__ConditionalOrExpression__OperandAssignment_1_3_1 ) |
| // InternalSEW.g:4233:3: rule__ConditionalOrExpression__OperandAssignment_1_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__OperandAssignment_1_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getOperandAssignment_1_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__Group_1_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group__0" |
| // InternalSEW.g:4242:1: rule__ConditionalAndExpression__Group__0 : rule__ConditionalAndExpression__Group__0__Impl rule__ConditionalAndExpression__Group__1 ; |
| public final void rule__ConditionalAndExpression__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4246:1: ( rule__ConditionalAndExpression__Group__0__Impl rule__ConditionalAndExpression__Group__1 ) |
| // InternalSEW.g:4247:2: rule__ConditionalAndExpression__Group__0__Impl rule__ConditionalAndExpression__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_27); |
| rule__ConditionalAndExpression__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group__0" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group__0__Impl" |
| // InternalSEW.g:4254:1: rule__ConditionalAndExpression__Group__0__Impl : ( ruleequalityExpression ) ; |
| public final void rule__ConditionalAndExpression__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4258:1: ( ( ruleequalityExpression ) ) |
| // InternalSEW.g:4259:1: ( ruleequalityExpression ) |
| { |
| // InternalSEW.g:4259:1: ( ruleequalityExpression ) |
| // InternalSEW.g:4260:2: ruleequalityExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getEqualityExpressionParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleequalityExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getEqualityExpressionParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group__1" |
| // InternalSEW.g:4269:1: rule__ConditionalAndExpression__Group__1 : rule__ConditionalAndExpression__Group__1__Impl ; |
| public final void rule__ConditionalAndExpression__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4273:1: ( rule__ConditionalAndExpression__Group__1__Impl ) |
| // InternalSEW.g:4274:2: rule__ConditionalAndExpression__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group__1" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group__1__Impl" |
| // InternalSEW.g:4280:1: rule__ConditionalAndExpression__Group__1__Impl : ( ( rule__ConditionalAndExpression__Group_1__0 )? ) ; |
| public final void rule__ConditionalAndExpression__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4284:1: ( ( ( rule__ConditionalAndExpression__Group_1__0 )? ) ) |
| // InternalSEW.g:4285:1: ( ( rule__ConditionalAndExpression__Group_1__0 )? ) |
| { |
| // InternalSEW.g:4285:1: ( ( rule__ConditionalAndExpression__Group_1__0 )? ) |
| // InternalSEW.g:4286:2: ( rule__ConditionalAndExpression__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getGroup_1()); |
| } |
| // InternalSEW.g:4287:2: ( rule__ConditionalAndExpression__Group_1__0 )? |
| int alt66=2; |
| int LA66_0 = input.LA(1); |
| |
| if ( ((LA66_0>=25 && LA66_0<=26)) ) { |
| alt66=1; |
| } |
| switch (alt66) { |
| case 1 : |
| // InternalSEW.g:4287:3: rule__ConditionalAndExpression__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1__0" |
| // InternalSEW.g:4296:1: rule__ConditionalAndExpression__Group_1__0 : rule__ConditionalAndExpression__Group_1__0__Impl rule__ConditionalAndExpression__Group_1__1 ; |
| public final void rule__ConditionalAndExpression__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4300:1: ( rule__ConditionalAndExpression__Group_1__0__Impl rule__ConditionalAndExpression__Group_1__1 ) |
| // InternalSEW.g:4301:2: rule__ConditionalAndExpression__Group_1__0__Impl rule__ConditionalAndExpression__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_27); |
| rule__ConditionalAndExpression__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1__0" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1__0__Impl" |
| // InternalSEW.g:4308:1: rule__ConditionalAndExpression__Group_1__0__Impl : ( () ) ; |
| public final void rule__ConditionalAndExpression__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4312:1: ( ( () ) ) |
| // InternalSEW.g:4313:1: ( () ) |
| { |
| // InternalSEW.g:4313:1: ( () ) |
| // InternalSEW.g:4314:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| // InternalSEW.g:4315:2: () |
| // InternalSEW.g:4315:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1__1" |
| // InternalSEW.g:4323:1: rule__ConditionalAndExpression__Group_1__1 : rule__ConditionalAndExpression__Group_1__1__Impl rule__ConditionalAndExpression__Group_1__2 ; |
| public final void rule__ConditionalAndExpression__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4327:1: ( rule__ConditionalAndExpression__Group_1__1__Impl rule__ConditionalAndExpression__Group_1__2 ) |
| // InternalSEW.g:4328:2: rule__ConditionalAndExpression__Group_1__1__Impl rule__ConditionalAndExpression__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__ConditionalAndExpression__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1__1" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1__1__Impl" |
| // InternalSEW.g:4335:1: rule__ConditionalAndExpression__Group_1__1__Impl : ( ( rule__ConditionalAndExpression__OperatorAssignment_1_1 ) ) ; |
| public final void rule__ConditionalAndExpression__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4339:1: ( ( ( rule__ConditionalAndExpression__OperatorAssignment_1_1 ) ) ) |
| // InternalSEW.g:4340:1: ( ( rule__ConditionalAndExpression__OperatorAssignment_1_1 ) ) |
| { |
| // InternalSEW.g:4340:1: ( ( rule__ConditionalAndExpression__OperatorAssignment_1_1 ) ) |
| // InternalSEW.g:4341:2: ( rule__ConditionalAndExpression__OperatorAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| // InternalSEW.g:4342:2: ( rule__ConditionalAndExpression__OperatorAssignment_1_1 ) |
| // InternalSEW.g:4342:3: rule__ConditionalAndExpression__OperatorAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__OperatorAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1__2" |
| // InternalSEW.g:4350:1: rule__ConditionalAndExpression__Group_1__2 : rule__ConditionalAndExpression__Group_1__2__Impl rule__ConditionalAndExpression__Group_1__3 ; |
| public final void rule__ConditionalAndExpression__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4354:1: ( rule__ConditionalAndExpression__Group_1__2__Impl rule__ConditionalAndExpression__Group_1__3 ) |
| // InternalSEW.g:4355:2: rule__ConditionalAndExpression__Group_1__2__Impl rule__ConditionalAndExpression__Group_1__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_27); |
| rule__ConditionalAndExpression__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__Group_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1__2" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1__2__Impl" |
| // InternalSEW.g:4362:1: rule__ConditionalAndExpression__Group_1__2__Impl : ( ( rule__ConditionalAndExpression__OperandAssignment_1_2 ) ) ; |
| public final void rule__ConditionalAndExpression__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4366:1: ( ( ( rule__ConditionalAndExpression__OperandAssignment_1_2 ) ) ) |
| // InternalSEW.g:4367:1: ( ( rule__ConditionalAndExpression__OperandAssignment_1_2 ) ) |
| { |
| // InternalSEW.g:4367:1: ( ( rule__ConditionalAndExpression__OperandAssignment_1_2 ) ) |
| // InternalSEW.g:4368:2: ( rule__ConditionalAndExpression__OperandAssignment_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getOperandAssignment_1_2()); |
| } |
| // InternalSEW.g:4369:2: ( rule__ConditionalAndExpression__OperandAssignment_1_2 ) |
| // InternalSEW.g:4369:3: rule__ConditionalAndExpression__OperandAssignment_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__OperandAssignment_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getOperandAssignment_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1__3" |
| // InternalSEW.g:4377:1: rule__ConditionalAndExpression__Group_1__3 : rule__ConditionalAndExpression__Group_1__3__Impl ; |
| public final void rule__ConditionalAndExpression__Group_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4381:1: ( rule__ConditionalAndExpression__Group_1__3__Impl ) |
| // InternalSEW.g:4382:2: rule__ConditionalAndExpression__Group_1__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__Group_1__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1__3" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1__3__Impl" |
| // InternalSEW.g:4388:1: rule__ConditionalAndExpression__Group_1__3__Impl : ( ( rule__ConditionalAndExpression__Group_1_3__0 )* ) ; |
| public final void rule__ConditionalAndExpression__Group_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4392:1: ( ( ( rule__ConditionalAndExpression__Group_1_3__0 )* ) ) |
| // InternalSEW.g:4393:1: ( ( rule__ConditionalAndExpression__Group_1_3__0 )* ) |
| { |
| // InternalSEW.g:4393:1: ( ( rule__ConditionalAndExpression__Group_1_3__0 )* ) |
| // InternalSEW.g:4394:2: ( rule__ConditionalAndExpression__Group_1_3__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getGroup_1_3()); |
| } |
| // InternalSEW.g:4395:2: ( rule__ConditionalAndExpression__Group_1_3__0 )* |
| loop67: |
| do { |
| int alt67=2; |
| int LA67_0 = input.LA(1); |
| |
| if ( ((LA67_0>=25 && LA67_0<=26)) ) { |
| alt67=1; |
| } |
| |
| |
| switch (alt67) { |
| case 1 : |
| // InternalSEW.g:4395:3: rule__ConditionalAndExpression__Group_1_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_28); |
| rule__ConditionalAndExpression__Group_1_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop67; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getGroup_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1_3__0" |
| // InternalSEW.g:4404:1: rule__ConditionalAndExpression__Group_1_3__0 : rule__ConditionalAndExpression__Group_1_3__0__Impl rule__ConditionalAndExpression__Group_1_3__1 ; |
| public final void rule__ConditionalAndExpression__Group_1_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4408:1: ( rule__ConditionalAndExpression__Group_1_3__0__Impl rule__ConditionalAndExpression__Group_1_3__1 ) |
| // InternalSEW.g:4409:2: rule__ConditionalAndExpression__Group_1_3__0__Impl rule__ConditionalAndExpression__Group_1_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__ConditionalAndExpression__Group_1_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__Group_1_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1_3__0" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1_3__0__Impl" |
| // InternalSEW.g:4416:1: rule__ConditionalAndExpression__Group_1_3__0__Impl : ( ( rule__ConditionalAndExpression__Alternatives_1_3_0 ) ) ; |
| public final void rule__ConditionalAndExpression__Group_1_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4420:1: ( ( ( rule__ConditionalAndExpression__Alternatives_1_3_0 ) ) ) |
| // InternalSEW.g:4421:1: ( ( rule__ConditionalAndExpression__Alternatives_1_3_0 ) ) |
| { |
| // InternalSEW.g:4421:1: ( ( rule__ConditionalAndExpression__Alternatives_1_3_0 ) ) |
| // InternalSEW.g:4422:2: ( rule__ConditionalAndExpression__Alternatives_1_3_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getAlternatives_1_3_0()); |
| } |
| // InternalSEW.g:4423:2: ( rule__ConditionalAndExpression__Alternatives_1_3_0 ) |
| // InternalSEW.g:4423:3: rule__ConditionalAndExpression__Alternatives_1_3_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__Alternatives_1_3_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getAlternatives_1_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1_3__1" |
| // InternalSEW.g:4431:1: rule__ConditionalAndExpression__Group_1_3__1 : rule__ConditionalAndExpression__Group_1_3__1__Impl ; |
| public final void rule__ConditionalAndExpression__Group_1_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4435:1: ( rule__ConditionalAndExpression__Group_1_3__1__Impl ) |
| // InternalSEW.g:4436:2: rule__ConditionalAndExpression__Group_1_3__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__Group_1_3__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1_3__1" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__Group_1_3__1__Impl" |
| // InternalSEW.g:4442:1: rule__ConditionalAndExpression__Group_1_3__1__Impl : ( ( rule__ConditionalAndExpression__OperandAssignment_1_3_1 ) ) ; |
| public final void rule__ConditionalAndExpression__Group_1_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4446:1: ( ( ( rule__ConditionalAndExpression__OperandAssignment_1_3_1 ) ) ) |
| // InternalSEW.g:4447:1: ( ( rule__ConditionalAndExpression__OperandAssignment_1_3_1 ) ) |
| { |
| // InternalSEW.g:4447:1: ( ( rule__ConditionalAndExpression__OperandAssignment_1_3_1 ) ) |
| // InternalSEW.g:4448:2: ( rule__ConditionalAndExpression__OperandAssignment_1_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getOperandAssignment_1_3_1()); |
| } |
| // InternalSEW.g:4449:2: ( rule__ConditionalAndExpression__OperandAssignment_1_3_1 ) |
| // InternalSEW.g:4449:3: rule__ConditionalAndExpression__OperandAssignment_1_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__OperandAssignment_1_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getOperandAssignment_1_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__Group_1_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__Group__0" |
| // InternalSEW.g:4458:1: rule__EqualityExpression__Group__0 : rule__EqualityExpression__Group__0__Impl rule__EqualityExpression__Group__1 ; |
| public final void rule__EqualityExpression__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4462:1: ( rule__EqualityExpression__Group__0__Impl rule__EqualityExpression__Group__1 ) |
| // InternalSEW.g:4463:2: rule__EqualityExpression__Group__0__Impl rule__EqualityExpression__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_29); |
| rule__EqualityExpression__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EqualityExpression__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__Group__0" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__Group__0__Impl" |
| // InternalSEW.g:4470:1: rule__EqualityExpression__Group__0__Impl : ( rulerelationalExpression ) ; |
| public final void rule__EqualityExpression__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4474:1: ( ( rulerelationalExpression ) ) |
| // InternalSEW.g:4475:1: ( rulerelationalExpression ) |
| { |
| // InternalSEW.g:4475:1: ( rulerelationalExpression ) |
| // InternalSEW.g:4476:2: rulerelationalExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getRelationalExpressionParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulerelationalExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getRelationalExpressionParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__Group__1" |
| // InternalSEW.g:4485:1: rule__EqualityExpression__Group__1 : rule__EqualityExpression__Group__1__Impl ; |
| public final void rule__EqualityExpression__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4489:1: ( rule__EqualityExpression__Group__1__Impl ) |
| // InternalSEW.g:4490:2: rule__EqualityExpression__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EqualityExpression__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__Group__1" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__Group__1__Impl" |
| // InternalSEW.g:4496:1: rule__EqualityExpression__Group__1__Impl : ( ( rule__EqualityExpression__Group_1__0 )? ) ; |
| public final void rule__EqualityExpression__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4500:1: ( ( ( rule__EqualityExpression__Group_1__0 )? ) ) |
| // InternalSEW.g:4501:1: ( ( rule__EqualityExpression__Group_1__0 )? ) |
| { |
| // InternalSEW.g:4501:1: ( ( rule__EqualityExpression__Group_1__0 )? ) |
| // InternalSEW.g:4502:2: ( rule__EqualityExpression__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getGroup_1()); |
| } |
| // InternalSEW.g:4503:2: ( rule__EqualityExpression__Group_1__0 )? |
| int alt68=2; |
| int LA68_0 = input.LA(1); |
| |
| if ( ((LA68_0>=27 && LA68_0<=31)) ) { |
| alt68=1; |
| } |
| switch (alt68) { |
| case 1 : |
| // InternalSEW.g:4503:3: rule__EqualityExpression__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EqualityExpression__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__Group_1__0" |
| // InternalSEW.g:4512:1: rule__EqualityExpression__Group_1__0 : rule__EqualityExpression__Group_1__0__Impl rule__EqualityExpression__Group_1__1 ; |
| public final void rule__EqualityExpression__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4516:1: ( rule__EqualityExpression__Group_1__0__Impl rule__EqualityExpression__Group_1__1 ) |
| // InternalSEW.g:4517:2: rule__EqualityExpression__Group_1__0__Impl rule__EqualityExpression__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_29); |
| rule__EqualityExpression__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EqualityExpression__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__Group_1__0" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__Group_1__0__Impl" |
| // InternalSEW.g:4524:1: rule__EqualityExpression__Group_1__0__Impl : ( () ) ; |
| public final void rule__EqualityExpression__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4528:1: ( ( () ) ) |
| // InternalSEW.g:4529:1: ( () ) |
| { |
| // InternalSEW.g:4529:1: ( () ) |
| // InternalSEW.g:4530:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| // InternalSEW.g:4531:2: () |
| // InternalSEW.g:4531:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__Group_1__1" |
| // InternalSEW.g:4539:1: rule__EqualityExpression__Group_1__1 : rule__EqualityExpression__Group_1__1__Impl rule__EqualityExpression__Group_1__2 ; |
| public final void rule__EqualityExpression__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4543:1: ( rule__EqualityExpression__Group_1__1__Impl rule__EqualityExpression__Group_1__2 ) |
| // InternalSEW.g:4544:2: rule__EqualityExpression__Group_1__1__Impl rule__EqualityExpression__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__EqualityExpression__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EqualityExpression__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__Group_1__1" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__Group_1__1__Impl" |
| // InternalSEW.g:4551:1: rule__EqualityExpression__Group_1__1__Impl : ( ( rule__EqualityExpression__OperatorAssignment_1_1 ) ) ; |
| public final void rule__EqualityExpression__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4555:1: ( ( ( rule__EqualityExpression__OperatorAssignment_1_1 ) ) ) |
| // InternalSEW.g:4556:1: ( ( rule__EqualityExpression__OperatorAssignment_1_1 ) ) |
| { |
| // InternalSEW.g:4556:1: ( ( rule__EqualityExpression__OperatorAssignment_1_1 ) ) |
| // InternalSEW.g:4557:2: ( rule__EqualityExpression__OperatorAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| // InternalSEW.g:4558:2: ( rule__EqualityExpression__OperatorAssignment_1_1 ) |
| // InternalSEW.g:4558:3: rule__EqualityExpression__OperatorAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EqualityExpression__OperatorAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__Group_1__2" |
| // InternalSEW.g:4566:1: rule__EqualityExpression__Group_1__2 : rule__EqualityExpression__Group_1__2__Impl ; |
| public final void rule__EqualityExpression__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4570:1: ( rule__EqualityExpression__Group_1__2__Impl ) |
| // InternalSEW.g:4571:2: rule__EqualityExpression__Group_1__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EqualityExpression__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__Group_1__2" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__Group_1__2__Impl" |
| // InternalSEW.g:4577:1: rule__EqualityExpression__Group_1__2__Impl : ( ( rule__EqualityExpression__OperandAssignment_1_2 ) ) ; |
| public final void rule__EqualityExpression__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4581:1: ( ( ( rule__EqualityExpression__OperandAssignment_1_2 ) ) ) |
| // InternalSEW.g:4582:1: ( ( rule__EqualityExpression__OperandAssignment_1_2 ) ) |
| { |
| // InternalSEW.g:4582:1: ( ( rule__EqualityExpression__OperandAssignment_1_2 ) ) |
| // InternalSEW.g:4583:2: ( rule__EqualityExpression__OperandAssignment_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getOperandAssignment_1_2()); |
| } |
| // InternalSEW.g:4584:2: ( rule__EqualityExpression__OperandAssignment_1_2 ) |
| // InternalSEW.g:4584:3: rule__EqualityExpression__OperandAssignment_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EqualityExpression__OperandAssignment_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getOperandAssignment_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__Group__0" |
| // InternalSEW.g:4593:1: rule__RelationalExpression__Group__0 : rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ; |
| public final void rule__RelationalExpression__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4597:1: ( rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ) |
| // InternalSEW.g:4598:2: rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_30); |
| rule__RelationalExpression__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RelationalExpression__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__Group__0" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__Group__0__Impl" |
| // InternalSEW.g:4605:1: rule__RelationalExpression__Group__0__Impl : ( ruleadditiveExpression ) ; |
| public final void rule__RelationalExpression__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4609:1: ( ( ruleadditiveExpression ) ) |
| // InternalSEW.g:4610:1: ( ruleadditiveExpression ) |
| { |
| // InternalSEW.g:4610:1: ( ruleadditiveExpression ) |
| // InternalSEW.g:4611:2: ruleadditiveExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleadditiveExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__Group__1" |
| // InternalSEW.g:4620:1: rule__RelationalExpression__Group__1 : rule__RelationalExpression__Group__1__Impl ; |
| public final void rule__RelationalExpression__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4624:1: ( rule__RelationalExpression__Group__1__Impl ) |
| // InternalSEW.g:4625:2: rule__RelationalExpression__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RelationalExpression__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__Group__1" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__Group__1__Impl" |
| // InternalSEW.g:4631:1: rule__RelationalExpression__Group__1__Impl : ( ( rule__RelationalExpression__Group_1__0 )? ) ; |
| public final void rule__RelationalExpression__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4635:1: ( ( ( rule__RelationalExpression__Group_1__0 )? ) ) |
| // InternalSEW.g:4636:1: ( ( rule__RelationalExpression__Group_1__0 )? ) |
| { |
| // InternalSEW.g:4636:1: ( ( rule__RelationalExpression__Group_1__0 )? ) |
| // InternalSEW.g:4637:2: ( rule__RelationalExpression__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); |
| } |
| // InternalSEW.g:4638:2: ( rule__RelationalExpression__Group_1__0 )? |
| int alt69=2; |
| int LA69_0 = input.LA(1); |
| |
| if ( ((LA69_0>=32 && LA69_0<=35)) ) { |
| alt69=1; |
| } |
| switch (alt69) { |
| case 1 : |
| // InternalSEW.g:4638:3: rule__RelationalExpression__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RelationalExpression__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__Group_1__0" |
| // InternalSEW.g:4647:1: rule__RelationalExpression__Group_1__0 : rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 ; |
| public final void rule__RelationalExpression__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4651:1: ( rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 ) |
| // InternalSEW.g:4652:2: rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_30); |
| rule__RelationalExpression__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RelationalExpression__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__Group_1__0" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__Group_1__0__Impl" |
| // InternalSEW.g:4659:1: rule__RelationalExpression__Group_1__0__Impl : ( () ) ; |
| public final void rule__RelationalExpression__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4663:1: ( ( () ) ) |
| // InternalSEW.g:4664:1: ( () ) |
| { |
| // InternalSEW.g:4664:1: ( () ) |
| // InternalSEW.g:4665:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| // InternalSEW.g:4666:2: () |
| // InternalSEW.g:4666:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__Group_1__1" |
| // InternalSEW.g:4674:1: rule__RelationalExpression__Group_1__1 : rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 ; |
| public final void rule__RelationalExpression__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4678:1: ( rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 ) |
| // InternalSEW.g:4679:2: rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__RelationalExpression__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RelationalExpression__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__Group_1__1" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__Group_1__1__Impl" |
| // InternalSEW.g:4686:1: rule__RelationalExpression__Group_1__1__Impl : ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ; |
| public final void rule__RelationalExpression__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4690:1: ( ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ) |
| // InternalSEW.g:4691:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) |
| { |
| // InternalSEW.g:4691:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) |
| // InternalSEW.g:4692:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| // InternalSEW.g:4693:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) |
| // InternalSEW.g:4693:3: rule__RelationalExpression__OperatorAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RelationalExpression__OperatorAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__Group_1__2" |
| // InternalSEW.g:4701:1: rule__RelationalExpression__Group_1__2 : rule__RelationalExpression__Group_1__2__Impl ; |
| public final void rule__RelationalExpression__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4705:1: ( rule__RelationalExpression__Group_1__2__Impl ) |
| // InternalSEW.g:4706:2: rule__RelationalExpression__Group_1__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RelationalExpression__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__Group_1__2" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__Group_1__2__Impl" |
| // InternalSEW.g:4712:1: rule__RelationalExpression__Group_1__2__Impl : ( ( rule__RelationalExpression__OperandAssignment_1_2 ) ) ; |
| public final void rule__RelationalExpression__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4716:1: ( ( ( rule__RelationalExpression__OperandAssignment_1_2 ) ) ) |
| // InternalSEW.g:4717:1: ( ( rule__RelationalExpression__OperandAssignment_1_2 ) ) |
| { |
| // InternalSEW.g:4717:1: ( ( rule__RelationalExpression__OperandAssignment_1_2 ) ) |
| // InternalSEW.g:4718:2: ( rule__RelationalExpression__OperandAssignment_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getOperandAssignment_1_2()); |
| } |
| // InternalSEW.g:4719:2: ( rule__RelationalExpression__OperandAssignment_1_2 ) |
| // InternalSEW.g:4719:3: rule__RelationalExpression__OperandAssignment_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RelationalExpression__OperandAssignment_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getOperandAssignment_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group__0" |
| // InternalSEW.g:4728:1: rule__AdditiveExpression__Group__0 : rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ; |
| public final void rule__AdditiveExpression__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4732:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ) |
| // InternalSEW.g:4733:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_31); |
| rule__AdditiveExpression__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group__0" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group__0__Impl" |
| // InternalSEW.g:4740:1: rule__AdditiveExpression__Group__0__Impl : ( rulemultiplicativeExpression ) ; |
| public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4744:1: ( ( rulemultiplicativeExpression ) ) |
| // InternalSEW.g:4745:1: ( rulemultiplicativeExpression ) |
| { |
| // InternalSEW.g:4745:1: ( rulemultiplicativeExpression ) |
| // InternalSEW.g:4746:2: rulemultiplicativeExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulemultiplicativeExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group__1" |
| // InternalSEW.g:4755:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ; |
| public final void rule__AdditiveExpression__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4759:1: ( rule__AdditiveExpression__Group__1__Impl ) |
| // InternalSEW.g:4760:2: rule__AdditiveExpression__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group__1" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group__1__Impl" |
| // InternalSEW.g:4766:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )? ) ; |
| public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4770:1: ( ( ( rule__AdditiveExpression__Group_1__0 )? ) ) |
| // InternalSEW.g:4771:1: ( ( rule__AdditiveExpression__Group_1__0 )? ) |
| { |
| // InternalSEW.g:4771:1: ( ( rule__AdditiveExpression__Group_1__0 )? ) |
| // InternalSEW.g:4772:2: ( rule__AdditiveExpression__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); |
| } |
| // InternalSEW.g:4773:2: ( rule__AdditiveExpression__Group_1__0 )? |
| int alt70=2; |
| alt70 = dfa70.predict(input); |
| switch (alt70) { |
| case 1 : |
| // InternalSEW.g:4773:3: rule__AdditiveExpression__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1__0" |
| // InternalSEW.g:4782:1: rule__AdditiveExpression__Group_1__0 : rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ; |
| public final void rule__AdditiveExpression__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4786:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ) |
| // InternalSEW.g:4787:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_31); |
| rule__AdditiveExpression__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1__0" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl" |
| // InternalSEW.g:4794:1: rule__AdditiveExpression__Group_1__0__Impl : ( () ) ; |
| public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4798:1: ( ( () ) ) |
| // InternalSEW.g:4799:1: ( () ) |
| { |
| // InternalSEW.g:4799:1: ( () ) |
| // InternalSEW.g:4800:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| // InternalSEW.g:4801:2: () |
| // InternalSEW.g:4801:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getExpressionOperandAction_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1__1" |
| // InternalSEW.g:4809:1: rule__AdditiveExpression__Group_1__1 : rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ; |
| public final void rule__AdditiveExpression__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4813:1: ( rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ) |
| // InternalSEW.g:4814:2: rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__AdditiveExpression__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1__1" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl" |
| // InternalSEW.g:4821:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__OperatorAssignment_1_1 ) ) ; |
| public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4825:1: ( ( ( rule__AdditiveExpression__OperatorAssignment_1_1 ) ) ) |
| // InternalSEW.g:4826:1: ( ( rule__AdditiveExpression__OperatorAssignment_1_1 ) ) |
| { |
| // InternalSEW.g:4826:1: ( ( rule__AdditiveExpression__OperatorAssignment_1_1 ) ) |
| // InternalSEW.g:4827:2: ( rule__AdditiveExpression__OperatorAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| // InternalSEW.g:4828:2: ( rule__AdditiveExpression__OperatorAssignment_1_1 ) |
| // InternalSEW.g:4828:3: rule__AdditiveExpression__OperatorAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__OperatorAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getOperatorAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1__2" |
| // InternalSEW.g:4836:1: rule__AdditiveExpression__Group_1__2 : rule__AdditiveExpression__Group_1__2__Impl rule__AdditiveExpression__Group_1__3 ; |
| public final void rule__AdditiveExpression__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4840:1: ( rule__AdditiveExpression__Group_1__2__Impl rule__AdditiveExpression__Group_1__3 ) |
| // InternalSEW.g:4841:2: rule__AdditiveExpression__Group_1__2__Impl rule__AdditiveExpression__Group_1__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_31); |
| rule__AdditiveExpression__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1__2" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1__2__Impl" |
| // InternalSEW.g:4848:1: rule__AdditiveExpression__Group_1__2__Impl : ( ( rule__AdditiveExpression__OperandAssignment_1_2 ) ) ; |
| public final void rule__AdditiveExpression__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4852:1: ( ( ( rule__AdditiveExpression__OperandAssignment_1_2 ) ) ) |
| // InternalSEW.g:4853:1: ( ( rule__AdditiveExpression__OperandAssignment_1_2 ) ) |
| { |
| // InternalSEW.g:4853:1: ( ( rule__AdditiveExpression__OperandAssignment_1_2 ) ) |
| // InternalSEW.g:4854:2: ( rule__AdditiveExpression__OperandAssignment_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getOperandAssignment_1_2()); |
| } |
| // InternalSEW.g:4855:2: ( rule__AdditiveExpression__OperandAssignment_1_2 ) |
| // InternalSEW.g:4855:3: rule__AdditiveExpression__OperandAssignment_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__OperandAssignment_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getOperandAssignment_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1__3" |
| // InternalSEW.g:4863:1: rule__AdditiveExpression__Group_1__3 : rule__AdditiveExpression__Group_1__3__Impl ; |
| public final void rule__AdditiveExpression__Group_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4867:1: ( rule__AdditiveExpression__Group_1__3__Impl ) |
| // InternalSEW.g:4868:2: rule__AdditiveExpression__Group_1__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group_1__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1__3" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1__3__Impl" |
| // InternalSEW.g:4874:1: rule__AdditiveExpression__Group_1__3__Impl : ( ( rule__AdditiveExpression__Group_1_3__0 )* ) ; |
| public final void rule__AdditiveExpression__Group_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4878:1: ( ( ( rule__AdditiveExpression__Group_1_3__0 )* ) ) |
| // InternalSEW.g:4879:1: ( ( rule__AdditiveExpression__Group_1_3__0 )* ) |
| { |
| // InternalSEW.g:4879:1: ( ( rule__AdditiveExpression__Group_1_3__0 )* ) |
| // InternalSEW.g:4880:2: ( rule__AdditiveExpression__Group_1_3__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getGroup_1_3()); |
| } |
| // InternalSEW.g:4881:2: ( rule__AdditiveExpression__Group_1_3__0 )* |
| loop71: |
| do { |
| int alt71=2; |
| alt71 = dfa71.predict(input); |
| switch (alt71) { |
| case 1 : |
| // InternalSEW.g:4881:3: rule__AdditiveExpression__Group_1_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_32); |
| rule__AdditiveExpression__Group_1_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop71; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getGroup_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1_3__0" |
| // InternalSEW.g:4890:1: rule__AdditiveExpression__Group_1_3__0 : rule__AdditiveExpression__Group_1_3__0__Impl rule__AdditiveExpression__Group_1_3__1 ; |
| public final void rule__AdditiveExpression__Group_1_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4894:1: ( rule__AdditiveExpression__Group_1_3__0__Impl rule__AdditiveExpression__Group_1_3__1 ) |
| // InternalSEW.g:4895:2: rule__AdditiveExpression__Group_1_3__0__Impl rule__AdditiveExpression__Group_1_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__AdditiveExpression__Group_1_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group_1_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1_3__0" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1_3__0__Impl" |
| // InternalSEW.g:4902:1: rule__AdditiveExpression__Group_1_3__0__Impl : ( '+' ) ; |
| public final void rule__AdditiveExpression__Group_1_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4906:1: ( ( '+' ) ) |
| // InternalSEW.g:4907:1: ( '+' ) |
| { |
| // InternalSEW.g:4907:1: ( '+' ) |
| // InternalSEW.g:4908:2: '+' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getPlusSignKeyword_1_3_0()); |
| } |
| match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getPlusSignKeyword_1_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1_3__1" |
| // InternalSEW.g:4917:1: rule__AdditiveExpression__Group_1_3__1 : rule__AdditiveExpression__Group_1_3__1__Impl ; |
| public final void rule__AdditiveExpression__Group_1_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4921:1: ( rule__AdditiveExpression__Group_1_3__1__Impl ) |
| // InternalSEW.g:4922:2: rule__AdditiveExpression__Group_1_3__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group_1_3__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1_3__1" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__Group_1_3__1__Impl" |
| // InternalSEW.g:4928:1: rule__AdditiveExpression__Group_1_3__1__Impl : ( ( rule__AdditiveExpression__OperandAssignment_1_3_1 ) ) ; |
| public final void rule__AdditiveExpression__Group_1_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4932:1: ( ( ( rule__AdditiveExpression__OperandAssignment_1_3_1 ) ) ) |
| // InternalSEW.g:4933:1: ( ( rule__AdditiveExpression__OperandAssignment_1_3_1 ) ) |
| { |
| // InternalSEW.g:4933:1: ( ( rule__AdditiveExpression__OperandAssignment_1_3_1 ) ) |
| // InternalSEW.g:4934:2: ( rule__AdditiveExpression__OperandAssignment_1_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getOperandAssignment_1_3_1()); |
| } |
| // InternalSEW.g:4935:2: ( rule__AdditiveExpression__OperandAssignment_1_3_1 ) |
| // InternalSEW.g:4935:3: rule__AdditiveExpression__OperandAssignment_1_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__OperandAssignment_1_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getOperandAssignment_1_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__Group_1_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group__0" |
| // InternalSEW.g:4944:1: rule__MultiplicativeExpression__Group__0 : rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ; |
| public final void rule__MultiplicativeExpression__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4948:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ) |
| // InternalSEW.g:4949:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_33); |
| rule__MultiplicativeExpression__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group__0" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl" |
| // InternalSEW.g:4956:1: rule__MultiplicativeExpression__Group__0__Impl : ( ruleprimaryExpression ) ; |
| public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4960:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:4961:1: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:4961:1: ( ruleprimaryExpression ) |
| // InternalSEW.g:4962:2: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getPrimaryExpressionParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getPrimaryExpressionParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group__1" |
| // InternalSEW.g:4971:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ; |
| public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4975:1: ( rule__MultiplicativeExpression__Group__1__Impl ) |
| // InternalSEW.g:4976:2: rule__MultiplicativeExpression__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group__1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl" |
| // InternalSEW.g:4982:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Alternatives_1 )? ) ; |
| public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:4986:1: ( ( ( rule__MultiplicativeExpression__Alternatives_1 )? ) ) |
| // InternalSEW.g:4987:1: ( ( rule__MultiplicativeExpression__Alternatives_1 )? ) |
| { |
| // InternalSEW.g:4987:1: ( ( rule__MultiplicativeExpression__Alternatives_1 )? ) |
| // InternalSEW.g:4988:2: ( rule__MultiplicativeExpression__Alternatives_1 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getAlternatives_1()); |
| } |
| // InternalSEW.g:4989:2: ( rule__MultiplicativeExpression__Alternatives_1 )? |
| int alt72=2; |
| int LA72_0 = input.LA(1); |
| |
| if ( ((LA72_0>=61 && LA72_0<=64)) ) { |
| alt72=1; |
| } |
| switch (alt72) { |
| case 1 : |
| // InternalSEW.g:4989:3: rule__MultiplicativeExpression__Alternatives_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Alternatives_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getAlternatives_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0__0" |
| // InternalSEW.g:4998:1: rule__MultiplicativeExpression__Group_1_0__0 : rule__MultiplicativeExpression__Group_1_0__0__Impl rule__MultiplicativeExpression__Group_1_0__1 ; |
| public final void rule__MultiplicativeExpression__Group_1_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5002:1: ( rule__MultiplicativeExpression__Group_1_0__0__Impl rule__MultiplicativeExpression__Group_1_0__1 ) |
| // InternalSEW.g:5003:2: rule__MultiplicativeExpression__Group_1_0__0__Impl rule__MultiplicativeExpression__Group_1_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_34); |
| rule__MultiplicativeExpression__Group_1_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0__0" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0__0__Impl" |
| // InternalSEW.g:5010:1: rule__MultiplicativeExpression__Group_1_0__0__Impl : ( () ) ; |
| public final void rule__MultiplicativeExpression__Group_1_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5014:1: ( ( () ) ) |
| // InternalSEW.g:5015:1: ( () ) |
| { |
| // InternalSEW.g:5015:1: ( () ) |
| // InternalSEW.g:5016:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getExpressionOperandAction_1_0_0()); |
| } |
| // InternalSEW.g:5017:2: () |
| // InternalSEW.g:5017:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getExpressionOperandAction_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0__1" |
| // InternalSEW.g:5025:1: rule__MultiplicativeExpression__Group_1_0__1 : rule__MultiplicativeExpression__Group_1_0__1__Impl rule__MultiplicativeExpression__Group_1_0__2 ; |
| public final void rule__MultiplicativeExpression__Group_1_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5029:1: ( rule__MultiplicativeExpression__Group_1_0__1__Impl rule__MultiplicativeExpression__Group_1_0__2 ) |
| // InternalSEW.g:5030:2: rule__MultiplicativeExpression__Group_1_0__1__Impl rule__MultiplicativeExpression__Group_1_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__MultiplicativeExpression__Group_1_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0__1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0__1__Impl" |
| // InternalSEW.g:5037:1: rule__MultiplicativeExpression__Group_1_0__1__Impl : ( ( rule__MultiplicativeExpression__OperatorAssignment_1_0_1 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5041:1: ( ( ( rule__MultiplicativeExpression__OperatorAssignment_1_0_1 ) ) ) |
| // InternalSEW.g:5042:1: ( ( rule__MultiplicativeExpression__OperatorAssignment_1_0_1 ) ) |
| { |
| // InternalSEW.g:5042:1: ( ( rule__MultiplicativeExpression__OperatorAssignment_1_0_1 ) ) |
| // InternalSEW.g:5043:2: ( rule__MultiplicativeExpression__OperatorAssignment_1_0_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_0_1()); |
| } |
| // InternalSEW.g:5044:2: ( rule__MultiplicativeExpression__OperatorAssignment_1_0_1 ) |
| // InternalSEW.g:5044:3: rule__MultiplicativeExpression__OperatorAssignment_1_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperatorAssignment_1_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0__2" |
| // InternalSEW.g:5052:1: rule__MultiplicativeExpression__Group_1_0__2 : rule__MultiplicativeExpression__Group_1_0__2__Impl rule__MultiplicativeExpression__Group_1_0__3 ; |
| public final void rule__MultiplicativeExpression__Group_1_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5056:1: ( rule__MultiplicativeExpression__Group_1_0__2__Impl rule__MultiplicativeExpression__Group_1_0__3 ) |
| // InternalSEW.g:5057:2: rule__MultiplicativeExpression__Group_1_0__2__Impl rule__MultiplicativeExpression__Group_1_0__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_34); |
| rule__MultiplicativeExpression__Group_1_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_0__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0__2" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0__2__Impl" |
| // InternalSEW.g:5064:1: rule__MultiplicativeExpression__Group_1_0__2__Impl : ( ( rule__MultiplicativeExpression__OperandAssignment_1_0_2 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5068:1: ( ( ( rule__MultiplicativeExpression__OperandAssignment_1_0_2 ) ) ) |
| // InternalSEW.g:5069:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_0_2 ) ) |
| { |
| // InternalSEW.g:5069:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_0_2 ) ) |
| // InternalSEW.g:5070:2: ( rule__MultiplicativeExpression__OperandAssignment_1_0_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_0_2()); |
| } |
| // InternalSEW.g:5071:2: ( rule__MultiplicativeExpression__OperandAssignment_1_0_2 ) |
| // InternalSEW.g:5071:3: rule__MultiplicativeExpression__OperandAssignment_1_0_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperandAssignment_1_0_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0__3" |
| // InternalSEW.g:5079:1: rule__MultiplicativeExpression__Group_1_0__3 : rule__MultiplicativeExpression__Group_1_0__3__Impl ; |
| public final void rule__MultiplicativeExpression__Group_1_0__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5083:1: ( rule__MultiplicativeExpression__Group_1_0__3__Impl ) |
| // InternalSEW.g:5084:2: rule__MultiplicativeExpression__Group_1_0__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_0__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0__3" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0__3__Impl" |
| // InternalSEW.g:5090:1: rule__MultiplicativeExpression__Group_1_0__3__Impl : ( ( rule__MultiplicativeExpression__Group_1_0_3__0 )* ) ; |
| public final void rule__MultiplicativeExpression__Group_1_0__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5094:1: ( ( ( rule__MultiplicativeExpression__Group_1_0_3__0 )* ) ) |
| // InternalSEW.g:5095:1: ( ( rule__MultiplicativeExpression__Group_1_0_3__0 )* ) |
| { |
| // InternalSEW.g:5095:1: ( ( rule__MultiplicativeExpression__Group_1_0_3__0 )* ) |
| // InternalSEW.g:5096:2: ( rule__MultiplicativeExpression__Group_1_0_3__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_0_3()); |
| } |
| // InternalSEW.g:5097:2: ( rule__MultiplicativeExpression__Group_1_0_3__0 )* |
| loop73: |
| do { |
| int alt73=2; |
| int LA73_0 = input.LA(1); |
| |
| if ( (LA73_0==61) ) { |
| alt73=1; |
| } |
| |
| |
| switch (alt73) { |
| case 1 : |
| // InternalSEW.g:5097:3: rule__MultiplicativeExpression__Group_1_0_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_35); |
| rule__MultiplicativeExpression__Group_1_0_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop73; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_0_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0__3__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0_3__0" |
| // InternalSEW.g:5106:1: rule__MultiplicativeExpression__Group_1_0_3__0 : rule__MultiplicativeExpression__Group_1_0_3__0__Impl rule__MultiplicativeExpression__Group_1_0_3__1 ; |
| public final void rule__MultiplicativeExpression__Group_1_0_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5110:1: ( rule__MultiplicativeExpression__Group_1_0_3__0__Impl rule__MultiplicativeExpression__Group_1_0_3__1 ) |
| // InternalSEW.g:5111:2: rule__MultiplicativeExpression__Group_1_0_3__0__Impl rule__MultiplicativeExpression__Group_1_0_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__MultiplicativeExpression__Group_1_0_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_0_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0_3__0" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0_3__0__Impl" |
| // InternalSEW.g:5118:1: rule__MultiplicativeExpression__Group_1_0_3__0__Impl : ( '*' ) ; |
| public final void rule__MultiplicativeExpression__Group_1_0_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5122:1: ( ( '*' ) ) |
| // InternalSEW.g:5123:1: ( '*' ) |
| { |
| // InternalSEW.g:5123:1: ( '*' ) |
| // InternalSEW.g:5124:2: '*' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getAsteriskKeyword_1_0_3_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getAsteriskKeyword_1_0_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0_3__1" |
| // InternalSEW.g:5133:1: rule__MultiplicativeExpression__Group_1_0_3__1 : rule__MultiplicativeExpression__Group_1_0_3__1__Impl ; |
| public final void rule__MultiplicativeExpression__Group_1_0_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5137:1: ( rule__MultiplicativeExpression__Group_1_0_3__1__Impl ) |
| // InternalSEW.g:5138:2: rule__MultiplicativeExpression__Group_1_0_3__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_0_3__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0_3__1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_0_3__1__Impl" |
| // InternalSEW.g:5144:1: rule__MultiplicativeExpression__Group_1_0_3__1__Impl : ( ( rule__MultiplicativeExpression__OperandAssignment_1_0_3_1 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_0_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5148:1: ( ( ( rule__MultiplicativeExpression__OperandAssignment_1_0_3_1 ) ) ) |
| // InternalSEW.g:5149:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_0_3_1 ) ) |
| { |
| // InternalSEW.g:5149:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_0_3_1 ) ) |
| // InternalSEW.g:5150:2: ( rule__MultiplicativeExpression__OperandAssignment_1_0_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_0_3_1()); |
| } |
| // InternalSEW.g:5151:2: ( rule__MultiplicativeExpression__OperandAssignment_1_0_3_1 ) |
| // InternalSEW.g:5151:3: rule__MultiplicativeExpression__OperandAssignment_1_0_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperandAssignment_1_0_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_0_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_0_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1__0" |
| // InternalSEW.g:5160:1: rule__MultiplicativeExpression__Group_1_1__0 : rule__MultiplicativeExpression__Group_1_1__0__Impl rule__MultiplicativeExpression__Group_1_1__1 ; |
| public final void rule__MultiplicativeExpression__Group_1_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5164:1: ( rule__MultiplicativeExpression__Group_1_1__0__Impl rule__MultiplicativeExpression__Group_1_1__1 ) |
| // InternalSEW.g:5165:2: rule__MultiplicativeExpression__Group_1_1__0__Impl rule__MultiplicativeExpression__Group_1_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_36); |
| rule__MultiplicativeExpression__Group_1_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1__0" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1__0__Impl" |
| // InternalSEW.g:5172:1: rule__MultiplicativeExpression__Group_1_1__0__Impl : ( () ) ; |
| public final void rule__MultiplicativeExpression__Group_1_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5176:1: ( ( () ) ) |
| // InternalSEW.g:5177:1: ( () ) |
| { |
| // InternalSEW.g:5177:1: ( () ) |
| // InternalSEW.g:5178:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getExpressionOperandAction_1_1_0()); |
| } |
| // InternalSEW.g:5179:2: () |
| // InternalSEW.g:5179:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getExpressionOperandAction_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1__1" |
| // InternalSEW.g:5187:1: rule__MultiplicativeExpression__Group_1_1__1 : rule__MultiplicativeExpression__Group_1_1__1__Impl rule__MultiplicativeExpression__Group_1_1__2 ; |
| public final void rule__MultiplicativeExpression__Group_1_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5191:1: ( rule__MultiplicativeExpression__Group_1_1__1__Impl rule__MultiplicativeExpression__Group_1_1__2 ) |
| // InternalSEW.g:5192:2: rule__MultiplicativeExpression__Group_1_1__1__Impl rule__MultiplicativeExpression__Group_1_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__MultiplicativeExpression__Group_1_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1__1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1__1__Impl" |
| // InternalSEW.g:5199:1: rule__MultiplicativeExpression__Group_1_1__1__Impl : ( ( rule__MultiplicativeExpression__OperatorAssignment_1_1_1 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5203:1: ( ( ( rule__MultiplicativeExpression__OperatorAssignment_1_1_1 ) ) ) |
| // InternalSEW.g:5204:1: ( ( rule__MultiplicativeExpression__OperatorAssignment_1_1_1 ) ) |
| { |
| // InternalSEW.g:5204:1: ( ( rule__MultiplicativeExpression__OperatorAssignment_1_1_1 ) ) |
| // InternalSEW.g:5205:2: ( rule__MultiplicativeExpression__OperatorAssignment_1_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_1_1()); |
| } |
| // InternalSEW.g:5206:2: ( rule__MultiplicativeExpression__OperatorAssignment_1_1_1 ) |
| // InternalSEW.g:5206:3: rule__MultiplicativeExpression__OperatorAssignment_1_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperatorAssignment_1_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1__2" |
| // InternalSEW.g:5214:1: rule__MultiplicativeExpression__Group_1_1__2 : rule__MultiplicativeExpression__Group_1_1__2__Impl rule__MultiplicativeExpression__Group_1_1__3 ; |
| public final void rule__MultiplicativeExpression__Group_1_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5218:1: ( rule__MultiplicativeExpression__Group_1_1__2__Impl rule__MultiplicativeExpression__Group_1_1__3 ) |
| // InternalSEW.g:5219:2: rule__MultiplicativeExpression__Group_1_1__2__Impl rule__MultiplicativeExpression__Group_1_1__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_36); |
| rule__MultiplicativeExpression__Group_1_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1__2" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1__2__Impl" |
| // InternalSEW.g:5226:1: rule__MultiplicativeExpression__Group_1_1__2__Impl : ( ( rule__MultiplicativeExpression__OperandAssignment_1_1_2 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5230:1: ( ( ( rule__MultiplicativeExpression__OperandAssignment_1_1_2 ) ) ) |
| // InternalSEW.g:5231:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_1_2 ) ) |
| { |
| // InternalSEW.g:5231:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_1_2 ) ) |
| // InternalSEW.g:5232:2: ( rule__MultiplicativeExpression__OperandAssignment_1_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_1_2()); |
| } |
| // InternalSEW.g:5233:2: ( rule__MultiplicativeExpression__OperandAssignment_1_1_2 ) |
| // InternalSEW.g:5233:3: rule__MultiplicativeExpression__OperandAssignment_1_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperandAssignment_1_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1__3" |
| // InternalSEW.g:5241:1: rule__MultiplicativeExpression__Group_1_1__3 : rule__MultiplicativeExpression__Group_1_1__3__Impl ; |
| public final void rule__MultiplicativeExpression__Group_1_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5245:1: ( rule__MultiplicativeExpression__Group_1_1__3__Impl ) |
| // InternalSEW.g:5246:2: rule__MultiplicativeExpression__Group_1_1__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_1__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1__3" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1__3__Impl" |
| // InternalSEW.g:5252:1: rule__MultiplicativeExpression__Group_1_1__3__Impl : ( ( rule__MultiplicativeExpression__Group_1_1_3__0 )* ) ; |
| public final void rule__MultiplicativeExpression__Group_1_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5256:1: ( ( ( rule__MultiplicativeExpression__Group_1_1_3__0 )* ) ) |
| // InternalSEW.g:5257:1: ( ( rule__MultiplicativeExpression__Group_1_1_3__0 )* ) |
| { |
| // InternalSEW.g:5257:1: ( ( rule__MultiplicativeExpression__Group_1_1_3__0 )* ) |
| // InternalSEW.g:5258:2: ( rule__MultiplicativeExpression__Group_1_1_3__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_1_3()); |
| } |
| // InternalSEW.g:5259:2: ( rule__MultiplicativeExpression__Group_1_1_3__0 )* |
| loop74: |
| do { |
| int alt74=2; |
| int LA74_0 = input.LA(1); |
| |
| if ( (LA74_0==62) ) { |
| alt74=1; |
| } |
| |
| |
| switch (alt74) { |
| case 1 : |
| // InternalSEW.g:5259:3: rule__MultiplicativeExpression__Group_1_1_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_37); |
| rule__MultiplicativeExpression__Group_1_1_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop74; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1_3__0" |
| // InternalSEW.g:5268:1: rule__MultiplicativeExpression__Group_1_1_3__0 : rule__MultiplicativeExpression__Group_1_1_3__0__Impl rule__MultiplicativeExpression__Group_1_1_3__1 ; |
| public final void rule__MultiplicativeExpression__Group_1_1_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5272:1: ( rule__MultiplicativeExpression__Group_1_1_3__0__Impl rule__MultiplicativeExpression__Group_1_1_3__1 ) |
| // InternalSEW.g:5273:2: rule__MultiplicativeExpression__Group_1_1_3__0__Impl rule__MultiplicativeExpression__Group_1_1_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__MultiplicativeExpression__Group_1_1_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_1_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1_3__0" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1_3__0__Impl" |
| // InternalSEW.g:5280:1: rule__MultiplicativeExpression__Group_1_1_3__0__Impl : ( '**' ) ; |
| public final void rule__MultiplicativeExpression__Group_1_1_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5284:1: ( ( '**' ) ) |
| // InternalSEW.g:5285:1: ( '**' ) |
| { |
| // InternalSEW.g:5285:1: ( '**' ) |
| // InternalSEW.g:5286:2: '**' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getAsteriskAsteriskKeyword_1_1_3_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getAsteriskAsteriskKeyword_1_1_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1_3__1" |
| // InternalSEW.g:5295:1: rule__MultiplicativeExpression__Group_1_1_3__1 : rule__MultiplicativeExpression__Group_1_1_3__1__Impl ; |
| public final void rule__MultiplicativeExpression__Group_1_1_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5299:1: ( rule__MultiplicativeExpression__Group_1_1_3__1__Impl ) |
| // InternalSEW.g:5300:2: rule__MultiplicativeExpression__Group_1_1_3__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_1_3__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1_3__1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_1_3__1__Impl" |
| // InternalSEW.g:5306:1: rule__MultiplicativeExpression__Group_1_1_3__1__Impl : ( ( rule__MultiplicativeExpression__OperandAssignment_1_1_3_1 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_1_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5310:1: ( ( ( rule__MultiplicativeExpression__OperandAssignment_1_1_3_1 ) ) ) |
| // InternalSEW.g:5311:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_1_3_1 ) ) |
| { |
| // InternalSEW.g:5311:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_1_3_1 ) ) |
| // InternalSEW.g:5312:2: ( rule__MultiplicativeExpression__OperandAssignment_1_1_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_1_3_1()); |
| } |
| // InternalSEW.g:5313:2: ( rule__MultiplicativeExpression__OperandAssignment_1_1_3_1 ) |
| // InternalSEW.g:5313:3: rule__MultiplicativeExpression__OperandAssignment_1_1_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperandAssignment_1_1_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_1_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_1_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2__0" |
| // InternalSEW.g:5322:1: rule__MultiplicativeExpression__Group_1_2__0 : rule__MultiplicativeExpression__Group_1_2__0__Impl rule__MultiplicativeExpression__Group_1_2__1 ; |
| public final void rule__MultiplicativeExpression__Group_1_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5326:1: ( rule__MultiplicativeExpression__Group_1_2__0__Impl rule__MultiplicativeExpression__Group_1_2__1 ) |
| // InternalSEW.g:5327:2: rule__MultiplicativeExpression__Group_1_2__0__Impl rule__MultiplicativeExpression__Group_1_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_38); |
| rule__MultiplicativeExpression__Group_1_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2__0" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2__0__Impl" |
| // InternalSEW.g:5334:1: rule__MultiplicativeExpression__Group_1_2__0__Impl : ( () ) ; |
| public final void rule__MultiplicativeExpression__Group_1_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5338:1: ( ( () ) ) |
| // InternalSEW.g:5339:1: ( () ) |
| { |
| // InternalSEW.g:5339:1: ( () ) |
| // InternalSEW.g:5340:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getExpressionOperandAction_1_2_0()); |
| } |
| // InternalSEW.g:5341:2: () |
| // InternalSEW.g:5341:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getExpressionOperandAction_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2__1" |
| // InternalSEW.g:5349:1: rule__MultiplicativeExpression__Group_1_2__1 : rule__MultiplicativeExpression__Group_1_2__1__Impl rule__MultiplicativeExpression__Group_1_2__2 ; |
| public final void rule__MultiplicativeExpression__Group_1_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5353:1: ( rule__MultiplicativeExpression__Group_1_2__1__Impl rule__MultiplicativeExpression__Group_1_2__2 ) |
| // InternalSEW.g:5354:2: rule__MultiplicativeExpression__Group_1_2__1__Impl rule__MultiplicativeExpression__Group_1_2__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__MultiplicativeExpression__Group_1_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_2__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2__1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2__1__Impl" |
| // InternalSEW.g:5361:1: rule__MultiplicativeExpression__Group_1_2__1__Impl : ( ( rule__MultiplicativeExpression__OperatorAssignment_1_2_1 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5365:1: ( ( ( rule__MultiplicativeExpression__OperatorAssignment_1_2_1 ) ) ) |
| // InternalSEW.g:5366:1: ( ( rule__MultiplicativeExpression__OperatorAssignment_1_2_1 ) ) |
| { |
| // InternalSEW.g:5366:1: ( ( rule__MultiplicativeExpression__OperatorAssignment_1_2_1 ) ) |
| // InternalSEW.g:5367:2: ( rule__MultiplicativeExpression__OperatorAssignment_1_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_2_1()); |
| } |
| // InternalSEW.g:5368:2: ( rule__MultiplicativeExpression__OperatorAssignment_1_2_1 ) |
| // InternalSEW.g:5368:3: rule__MultiplicativeExpression__OperatorAssignment_1_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperatorAssignment_1_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2__2" |
| // InternalSEW.g:5376:1: rule__MultiplicativeExpression__Group_1_2__2 : rule__MultiplicativeExpression__Group_1_2__2__Impl rule__MultiplicativeExpression__Group_1_2__3 ; |
| public final void rule__MultiplicativeExpression__Group_1_2__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5380:1: ( rule__MultiplicativeExpression__Group_1_2__2__Impl rule__MultiplicativeExpression__Group_1_2__3 ) |
| // InternalSEW.g:5381:2: rule__MultiplicativeExpression__Group_1_2__2__Impl rule__MultiplicativeExpression__Group_1_2__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_38); |
| rule__MultiplicativeExpression__Group_1_2__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_2__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2__2" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2__2__Impl" |
| // InternalSEW.g:5388:1: rule__MultiplicativeExpression__Group_1_2__2__Impl : ( ( rule__MultiplicativeExpression__OperandAssignment_1_2_2 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_2__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5392:1: ( ( ( rule__MultiplicativeExpression__OperandAssignment_1_2_2 ) ) ) |
| // InternalSEW.g:5393:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_2_2 ) ) |
| { |
| // InternalSEW.g:5393:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_2_2 ) ) |
| // InternalSEW.g:5394:2: ( rule__MultiplicativeExpression__OperandAssignment_1_2_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_2_2()); |
| } |
| // InternalSEW.g:5395:2: ( rule__MultiplicativeExpression__OperandAssignment_1_2_2 ) |
| // InternalSEW.g:5395:3: rule__MultiplicativeExpression__OperandAssignment_1_2_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperandAssignment_1_2_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_2_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2__2__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2__3" |
| // InternalSEW.g:5403:1: rule__MultiplicativeExpression__Group_1_2__3 : rule__MultiplicativeExpression__Group_1_2__3__Impl ; |
| public final void rule__MultiplicativeExpression__Group_1_2__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5407:1: ( rule__MultiplicativeExpression__Group_1_2__3__Impl ) |
| // InternalSEW.g:5408:2: rule__MultiplicativeExpression__Group_1_2__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_2__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2__3" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2__3__Impl" |
| // InternalSEW.g:5414:1: rule__MultiplicativeExpression__Group_1_2__3__Impl : ( ( rule__MultiplicativeExpression__Group_1_2_3__0 )* ) ; |
| public final void rule__MultiplicativeExpression__Group_1_2__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5418:1: ( ( ( rule__MultiplicativeExpression__Group_1_2_3__0 )* ) ) |
| // InternalSEW.g:5419:1: ( ( rule__MultiplicativeExpression__Group_1_2_3__0 )* ) |
| { |
| // InternalSEW.g:5419:1: ( ( rule__MultiplicativeExpression__Group_1_2_3__0 )* ) |
| // InternalSEW.g:5420:2: ( rule__MultiplicativeExpression__Group_1_2_3__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_2_3()); |
| } |
| // InternalSEW.g:5421:2: ( rule__MultiplicativeExpression__Group_1_2_3__0 )* |
| loop75: |
| do { |
| int alt75=2; |
| int LA75_0 = input.LA(1); |
| |
| if ( (LA75_0==63) ) { |
| alt75=1; |
| } |
| |
| |
| switch (alt75) { |
| case 1 : |
| // InternalSEW.g:5421:3: rule__MultiplicativeExpression__Group_1_2_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_39); |
| rule__MultiplicativeExpression__Group_1_2_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop75; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_2_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2__3__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2_3__0" |
| // InternalSEW.g:5430:1: rule__MultiplicativeExpression__Group_1_2_3__0 : rule__MultiplicativeExpression__Group_1_2_3__0__Impl rule__MultiplicativeExpression__Group_1_2_3__1 ; |
| public final void rule__MultiplicativeExpression__Group_1_2_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5434:1: ( rule__MultiplicativeExpression__Group_1_2_3__0__Impl rule__MultiplicativeExpression__Group_1_2_3__1 ) |
| // InternalSEW.g:5435:2: rule__MultiplicativeExpression__Group_1_2_3__0__Impl rule__MultiplicativeExpression__Group_1_2_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__MultiplicativeExpression__Group_1_2_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_2_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2_3__0" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2_3__0__Impl" |
| // InternalSEW.g:5442:1: rule__MultiplicativeExpression__Group_1_2_3__0__Impl : ( '/' ) ; |
| public final void rule__MultiplicativeExpression__Group_1_2_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5446:1: ( ( '/' ) ) |
| // InternalSEW.g:5447:1: ( '/' ) |
| { |
| // InternalSEW.g:5447:1: ( '/' ) |
| // InternalSEW.g:5448:2: '/' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getSolidusKeyword_1_2_3_0()); |
| } |
| match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getSolidusKeyword_1_2_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2_3__1" |
| // InternalSEW.g:5457:1: rule__MultiplicativeExpression__Group_1_2_3__1 : rule__MultiplicativeExpression__Group_1_2_3__1__Impl ; |
| public final void rule__MultiplicativeExpression__Group_1_2_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5461:1: ( rule__MultiplicativeExpression__Group_1_2_3__1__Impl ) |
| // InternalSEW.g:5462:2: rule__MultiplicativeExpression__Group_1_2_3__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_2_3__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2_3__1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_2_3__1__Impl" |
| // InternalSEW.g:5468:1: rule__MultiplicativeExpression__Group_1_2_3__1__Impl : ( ( rule__MultiplicativeExpression__OperandAssignment_1_2_3_1 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_2_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5472:1: ( ( ( rule__MultiplicativeExpression__OperandAssignment_1_2_3_1 ) ) ) |
| // InternalSEW.g:5473:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_2_3_1 ) ) |
| { |
| // InternalSEW.g:5473:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_2_3_1 ) ) |
| // InternalSEW.g:5474:2: ( rule__MultiplicativeExpression__OperandAssignment_1_2_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_2_3_1()); |
| } |
| // InternalSEW.g:5475:2: ( rule__MultiplicativeExpression__OperandAssignment_1_2_3_1 ) |
| // InternalSEW.g:5475:3: rule__MultiplicativeExpression__OperandAssignment_1_2_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperandAssignment_1_2_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_2_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_2_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3__0" |
| // InternalSEW.g:5484:1: rule__MultiplicativeExpression__Group_1_3__0 : rule__MultiplicativeExpression__Group_1_3__0__Impl rule__MultiplicativeExpression__Group_1_3__1 ; |
| public final void rule__MultiplicativeExpression__Group_1_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5488:1: ( rule__MultiplicativeExpression__Group_1_3__0__Impl rule__MultiplicativeExpression__Group_1_3__1 ) |
| // InternalSEW.g:5489:2: rule__MultiplicativeExpression__Group_1_3__0__Impl rule__MultiplicativeExpression__Group_1_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_33); |
| rule__MultiplicativeExpression__Group_1_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3__0" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3__0__Impl" |
| // InternalSEW.g:5496:1: rule__MultiplicativeExpression__Group_1_3__0__Impl : ( () ) ; |
| public final void rule__MultiplicativeExpression__Group_1_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5500:1: ( ( () ) ) |
| // InternalSEW.g:5501:1: ( () ) |
| { |
| // InternalSEW.g:5501:1: ( () ) |
| // InternalSEW.g:5502:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getExpressionOperandAction_1_3_0()); |
| } |
| // InternalSEW.g:5503:2: () |
| // InternalSEW.g:5503:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getExpressionOperandAction_1_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3__1" |
| // InternalSEW.g:5511:1: rule__MultiplicativeExpression__Group_1_3__1 : rule__MultiplicativeExpression__Group_1_3__1__Impl rule__MultiplicativeExpression__Group_1_3__2 ; |
| public final void rule__MultiplicativeExpression__Group_1_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5515:1: ( rule__MultiplicativeExpression__Group_1_3__1__Impl rule__MultiplicativeExpression__Group_1_3__2 ) |
| // InternalSEW.g:5516:2: rule__MultiplicativeExpression__Group_1_3__1__Impl rule__MultiplicativeExpression__Group_1_3__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__MultiplicativeExpression__Group_1_3__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_3__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3__1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3__1__Impl" |
| // InternalSEW.g:5523:1: rule__MultiplicativeExpression__Group_1_3__1__Impl : ( ( rule__MultiplicativeExpression__OperatorAssignment_1_3_1 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5527:1: ( ( ( rule__MultiplicativeExpression__OperatorAssignment_1_3_1 ) ) ) |
| // InternalSEW.g:5528:1: ( ( rule__MultiplicativeExpression__OperatorAssignment_1_3_1 ) ) |
| { |
| // InternalSEW.g:5528:1: ( ( rule__MultiplicativeExpression__OperatorAssignment_1_3_1 ) ) |
| // InternalSEW.g:5529:2: ( rule__MultiplicativeExpression__OperatorAssignment_1_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_3_1()); |
| } |
| // InternalSEW.g:5530:2: ( rule__MultiplicativeExpression__OperatorAssignment_1_3_1 ) |
| // InternalSEW.g:5530:3: rule__MultiplicativeExpression__OperatorAssignment_1_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperatorAssignment_1_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_1_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3__2" |
| // InternalSEW.g:5538:1: rule__MultiplicativeExpression__Group_1_3__2 : rule__MultiplicativeExpression__Group_1_3__2__Impl rule__MultiplicativeExpression__Group_1_3__3 ; |
| public final void rule__MultiplicativeExpression__Group_1_3__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5542:1: ( rule__MultiplicativeExpression__Group_1_3__2__Impl rule__MultiplicativeExpression__Group_1_3__3 ) |
| // InternalSEW.g:5543:2: rule__MultiplicativeExpression__Group_1_3__2__Impl rule__MultiplicativeExpression__Group_1_3__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_40); |
| rule__MultiplicativeExpression__Group_1_3__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_3__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3__2" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3__2__Impl" |
| // InternalSEW.g:5550:1: rule__MultiplicativeExpression__Group_1_3__2__Impl : ( ( rule__MultiplicativeExpression__OperandAssignment_1_3_2 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_3__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5554:1: ( ( ( rule__MultiplicativeExpression__OperandAssignment_1_3_2 ) ) ) |
| // InternalSEW.g:5555:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_3_2 ) ) |
| { |
| // InternalSEW.g:5555:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_3_2 ) ) |
| // InternalSEW.g:5556:2: ( rule__MultiplicativeExpression__OperandAssignment_1_3_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_3_2()); |
| } |
| // InternalSEW.g:5557:2: ( rule__MultiplicativeExpression__OperandAssignment_1_3_2 ) |
| // InternalSEW.g:5557:3: rule__MultiplicativeExpression__OperandAssignment_1_3_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperandAssignment_1_3_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_3_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3__2__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3__3" |
| // InternalSEW.g:5565:1: rule__MultiplicativeExpression__Group_1_3__3 : rule__MultiplicativeExpression__Group_1_3__3__Impl ; |
| public final void rule__MultiplicativeExpression__Group_1_3__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5569:1: ( rule__MultiplicativeExpression__Group_1_3__3__Impl ) |
| // InternalSEW.g:5570:2: rule__MultiplicativeExpression__Group_1_3__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_3__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3__3" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3__3__Impl" |
| // InternalSEW.g:5576:1: rule__MultiplicativeExpression__Group_1_3__3__Impl : ( ( rule__MultiplicativeExpression__Group_1_3_3__0 )* ) ; |
| public final void rule__MultiplicativeExpression__Group_1_3__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5580:1: ( ( ( rule__MultiplicativeExpression__Group_1_3_3__0 )* ) ) |
| // InternalSEW.g:5581:1: ( ( rule__MultiplicativeExpression__Group_1_3_3__0 )* ) |
| { |
| // InternalSEW.g:5581:1: ( ( rule__MultiplicativeExpression__Group_1_3_3__0 )* ) |
| // InternalSEW.g:5582:2: ( rule__MultiplicativeExpression__Group_1_3_3__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_3_3()); |
| } |
| // InternalSEW.g:5583:2: ( rule__MultiplicativeExpression__Group_1_3_3__0 )* |
| loop76: |
| do { |
| int alt76=2; |
| int LA76_0 = input.LA(1); |
| |
| if ( (LA76_0==64) ) { |
| alt76=1; |
| } |
| |
| |
| switch (alt76) { |
| case 1 : |
| // InternalSEW.g:5583:3: rule__MultiplicativeExpression__Group_1_3_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_41); |
| rule__MultiplicativeExpression__Group_1_3_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop76; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1_3_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3__3__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3_3__0" |
| // InternalSEW.g:5592:1: rule__MultiplicativeExpression__Group_1_3_3__0 : rule__MultiplicativeExpression__Group_1_3_3__0__Impl rule__MultiplicativeExpression__Group_1_3_3__1 ; |
| public final void rule__MultiplicativeExpression__Group_1_3_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5596:1: ( rule__MultiplicativeExpression__Group_1_3_3__0__Impl rule__MultiplicativeExpression__Group_1_3_3__1 ) |
| // InternalSEW.g:5597:2: rule__MultiplicativeExpression__Group_1_3_3__0__Impl rule__MultiplicativeExpression__Group_1_3_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__MultiplicativeExpression__Group_1_3_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_3_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3_3__0" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3_3__0__Impl" |
| // InternalSEW.g:5604:1: rule__MultiplicativeExpression__Group_1_3_3__0__Impl : ( '%' ) ; |
| public final void rule__MultiplicativeExpression__Group_1_3_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5608:1: ( ( '%' ) ) |
| // InternalSEW.g:5609:1: ( '%' ) |
| { |
| // InternalSEW.g:5609:1: ( '%' ) |
| // InternalSEW.g:5610:2: '%' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getPercentSignKeyword_1_3_3_0()); |
| } |
| match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getPercentSignKeyword_1_3_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3_3__1" |
| // InternalSEW.g:5619:1: rule__MultiplicativeExpression__Group_1_3_3__1 : rule__MultiplicativeExpression__Group_1_3_3__1__Impl ; |
| public final void rule__MultiplicativeExpression__Group_1_3_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5623:1: ( rule__MultiplicativeExpression__Group_1_3_3__1__Impl ) |
| // InternalSEW.g:5624:2: rule__MultiplicativeExpression__Group_1_3_3__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__Group_1_3_3__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3_3__1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__Group_1_3_3__1__Impl" |
| // InternalSEW.g:5630:1: rule__MultiplicativeExpression__Group_1_3_3__1__Impl : ( ( rule__MultiplicativeExpression__OperandAssignment_1_3_3_1 ) ) ; |
| public final void rule__MultiplicativeExpression__Group_1_3_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5634:1: ( ( ( rule__MultiplicativeExpression__OperandAssignment_1_3_3_1 ) ) ) |
| // InternalSEW.g:5635:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_3_3_1 ) ) |
| { |
| // InternalSEW.g:5635:1: ( ( rule__MultiplicativeExpression__OperandAssignment_1_3_3_1 ) ) |
| // InternalSEW.g:5636:2: ( rule__MultiplicativeExpression__OperandAssignment_1_3_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_3_3_1()); |
| } |
| // InternalSEW.g:5637:2: ( rule__MultiplicativeExpression__OperandAssignment_1_3_3_1 ) |
| // InternalSEW.g:5637:3: rule__MultiplicativeExpression__OperandAssignment_1_3_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicativeExpression__OperandAssignment_1_3_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandAssignment_1_3_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__Group_1_3_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_0__0" |
| // InternalSEW.g:5646:1: rule__PrimaryExpression__Group_0__0 : rule__PrimaryExpression__Group_0__0__Impl rule__PrimaryExpression__Group_0__1 ; |
| public final void rule__PrimaryExpression__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5650:1: ( rule__PrimaryExpression__Group_0__0__Impl rule__PrimaryExpression__Group_0__1 ) |
| // InternalSEW.g:5651:2: rule__PrimaryExpression__Group_0__0__Impl rule__PrimaryExpression__Group_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__PrimaryExpression__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_0__0" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_0__0__Impl" |
| // InternalSEW.g:5658:1: rule__PrimaryExpression__Group_0__0__Impl : ( '+' ) ; |
| public final void rule__PrimaryExpression__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5662:1: ( ( '+' ) ) |
| // InternalSEW.g:5663:1: ( '+' ) |
| { |
| // InternalSEW.g:5663:1: ( '+' ) |
| // InternalSEW.g:5664:2: '+' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getPlusSignKeyword_0_0()); |
| } |
| match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getPlusSignKeyword_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_0__1" |
| // InternalSEW.g:5673:1: rule__PrimaryExpression__Group_0__1 : rule__PrimaryExpression__Group_0__1__Impl ; |
| public final void rule__PrimaryExpression__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5677:1: ( rule__PrimaryExpression__Group_0__1__Impl ) |
| // InternalSEW.g:5678:2: rule__PrimaryExpression__Group_0__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_0__1" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_0__1__Impl" |
| // InternalSEW.g:5684:1: rule__PrimaryExpression__Group_0__1__Impl : ( ruleprimaryExpression ) ; |
| public final void rule__PrimaryExpression__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5688:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:5689:1: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:5689:1: ( ruleprimaryExpression ) |
| // InternalSEW.g:5690:2: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getPrimaryExpressionParserRuleCall_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getPrimaryExpressionParserRuleCall_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_1__0" |
| // InternalSEW.g:5700:1: rule__PrimaryExpression__Group_1__0 : rule__PrimaryExpression__Group_1__0__Impl rule__PrimaryExpression__Group_1__1 ; |
| public final void rule__PrimaryExpression__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5704:1: ( rule__PrimaryExpression__Group_1__0__Impl rule__PrimaryExpression__Group_1__1 ) |
| // InternalSEW.g:5705:2: rule__PrimaryExpression__Group_1__0__Impl rule__PrimaryExpression__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_42); |
| rule__PrimaryExpression__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_1__0" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_1__0__Impl" |
| // InternalSEW.g:5712:1: rule__PrimaryExpression__Group_1__0__Impl : ( () ) ; |
| public final void rule__PrimaryExpression__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5716:1: ( ( () ) ) |
| // InternalSEW.g:5717:1: ( () ) |
| { |
| // InternalSEW.g:5717:1: ( () ) |
| // InternalSEW.g:5718:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getExpressionAction_1_0()); |
| } |
| // InternalSEW.g:5719:2: () |
| // InternalSEW.g:5719:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getExpressionAction_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_1__1" |
| // InternalSEW.g:5727:1: rule__PrimaryExpression__Group_1__1 : rule__PrimaryExpression__Group_1__1__Impl ; |
| public final void rule__PrimaryExpression__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5731:1: ( rule__PrimaryExpression__Group_1__1__Impl ) |
| // InternalSEW.g:5732:2: rule__PrimaryExpression__Group_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_1__1" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_1__1__Impl" |
| // InternalSEW.g:5738:1: rule__PrimaryExpression__Group_1__1__Impl : ( ( rule__PrimaryExpression__Group_1_1__0 ) ) ; |
| public final void rule__PrimaryExpression__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5742:1: ( ( ( rule__PrimaryExpression__Group_1_1__0 ) ) ) |
| // InternalSEW.g:5743:1: ( ( rule__PrimaryExpression__Group_1_1__0 ) ) |
| { |
| // InternalSEW.g:5743:1: ( ( rule__PrimaryExpression__Group_1_1__0 ) ) |
| // InternalSEW.g:5744:2: ( rule__PrimaryExpression__Group_1_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getGroup_1_1()); |
| } |
| // InternalSEW.g:5745:2: ( rule__PrimaryExpression__Group_1_1__0 ) |
| // InternalSEW.g:5745:3: rule__PrimaryExpression__Group_1_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_1_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getGroup_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_1_1__0" |
| // InternalSEW.g:5754:1: rule__PrimaryExpression__Group_1_1__0 : rule__PrimaryExpression__Group_1_1__0__Impl rule__PrimaryExpression__Group_1_1__1 ; |
| public final void rule__PrimaryExpression__Group_1_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5758:1: ( rule__PrimaryExpression__Group_1_1__0__Impl rule__PrimaryExpression__Group_1_1__1 ) |
| // InternalSEW.g:5759:2: rule__PrimaryExpression__Group_1_1__0__Impl rule__PrimaryExpression__Group_1_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__PrimaryExpression__Group_1_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_1_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_1_1__0" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_1_1__0__Impl" |
| // InternalSEW.g:5766:1: rule__PrimaryExpression__Group_1_1__0__Impl : ( ( rule__PrimaryExpression__OperatorAssignment_1_1_0 ) ) ; |
| public final void rule__PrimaryExpression__Group_1_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5770:1: ( ( ( rule__PrimaryExpression__OperatorAssignment_1_1_0 ) ) ) |
| // InternalSEW.g:5771:1: ( ( rule__PrimaryExpression__OperatorAssignment_1_1_0 ) ) |
| { |
| // InternalSEW.g:5771:1: ( ( rule__PrimaryExpression__OperatorAssignment_1_1_0 ) ) |
| // InternalSEW.g:5772:2: ( rule__PrimaryExpression__OperatorAssignment_1_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getOperatorAssignment_1_1_0()); |
| } |
| // InternalSEW.g:5773:2: ( rule__PrimaryExpression__OperatorAssignment_1_1_0 ) |
| // InternalSEW.g:5773:3: rule__PrimaryExpression__OperatorAssignment_1_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__OperatorAssignment_1_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getOperatorAssignment_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_1_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_1_1__1" |
| // InternalSEW.g:5781:1: rule__PrimaryExpression__Group_1_1__1 : rule__PrimaryExpression__Group_1_1__1__Impl ; |
| public final void rule__PrimaryExpression__Group_1_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5785:1: ( rule__PrimaryExpression__Group_1_1__1__Impl ) |
| // InternalSEW.g:5786:2: rule__PrimaryExpression__Group_1_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_1_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_1_1__1" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_1_1__1__Impl" |
| // InternalSEW.g:5792:1: rule__PrimaryExpression__Group_1_1__1__Impl : ( ( rule__PrimaryExpression__OperandAssignment_1_1_1 ) ) ; |
| public final void rule__PrimaryExpression__Group_1_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5796:1: ( ( ( rule__PrimaryExpression__OperandAssignment_1_1_1 ) ) ) |
| // InternalSEW.g:5797:1: ( ( rule__PrimaryExpression__OperandAssignment_1_1_1 ) ) |
| { |
| // InternalSEW.g:5797:1: ( ( rule__PrimaryExpression__OperandAssignment_1_1_1 ) ) |
| // InternalSEW.g:5798:2: ( rule__PrimaryExpression__OperandAssignment_1_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getOperandAssignment_1_1_1()); |
| } |
| // InternalSEW.g:5799:2: ( rule__PrimaryExpression__OperandAssignment_1_1_1 ) |
| // InternalSEW.g:5799:3: rule__PrimaryExpression__OperandAssignment_1_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__OperandAssignment_1_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getOperandAssignment_1_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_1_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_2__0" |
| // InternalSEW.g:5808:1: rule__PrimaryExpression__Group_2__0 : rule__PrimaryExpression__Group_2__0__Impl rule__PrimaryExpression__Group_2__1 ; |
| public final void rule__PrimaryExpression__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5812:1: ( rule__PrimaryExpression__Group_2__0__Impl rule__PrimaryExpression__Group_2__1 ) |
| // InternalSEW.g:5813:2: rule__PrimaryExpression__Group_2__0__Impl rule__PrimaryExpression__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_43); |
| rule__PrimaryExpression__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_2__0" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_2__0__Impl" |
| // InternalSEW.g:5820:1: rule__PrimaryExpression__Group_2__0__Impl : ( () ) ; |
| public final void rule__PrimaryExpression__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5824:1: ( ( () ) ) |
| // InternalSEW.g:5825:1: ( () ) |
| { |
| // InternalSEW.g:5825:1: ( () ) |
| // InternalSEW.g:5826:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getExpressionAction_2_0()); |
| } |
| // InternalSEW.g:5827:2: () |
| // InternalSEW.g:5827:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getExpressionAction_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_2__1" |
| // InternalSEW.g:5835:1: rule__PrimaryExpression__Group_2__1 : rule__PrimaryExpression__Group_2__1__Impl ; |
| public final void rule__PrimaryExpression__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5839:1: ( rule__PrimaryExpression__Group_2__1__Impl ) |
| // InternalSEW.g:5840:2: rule__PrimaryExpression__Group_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_2__1" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_2__1__Impl" |
| // InternalSEW.g:5846:1: rule__PrimaryExpression__Group_2__1__Impl : ( ( rule__PrimaryExpression__Group_2_1__0 ) ) ; |
| public final void rule__PrimaryExpression__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5850:1: ( ( ( rule__PrimaryExpression__Group_2_1__0 ) ) ) |
| // InternalSEW.g:5851:1: ( ( rule__PrimaryExpression__Group_2_1__0 ) ) |
| { |
| // InternalSEW.g:5851:1: ( ( rule__PrimaryExpression__Group_2_1__0 ) ) |
| // InternalSEW.g:5852:2: ( rule__PrimaryExpression__Group_2_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getGroup_2_1()); |
| } |
| // InternalSEW.g:5853:2: ( rule__PrimaryExpression__Group_2_1__0 ) |
| // InternalSEW.g:5853:3: rule__PrimaryExpression__Group_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getGroup_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_2_1__0" |
| // InternalSEW.g:5862:1: rule__PrimaryExpression__Group_2_1__0 : rule__PrimaryExpression__Group_2_1__0__Impl rule__PrimaryExpression__Group_2_1__1 ; |
| public final void rule__PrimaryExpression__Group_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5866:1: ( rule__PrimaryExpression__Group_2_1__0__Impl rule__PrimaryExpression__Group_2_1__1 ) |
| // InternalSEW.g:5867:2: rule__PrimaryExpression__Group_2_1__0__Impl rule__PrimaryExpression__Group_2_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__PrimaryExpression__Group_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_2_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_2_1__0" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_2_1__0__Impl" |
| // InternalSEW.g:5874:1: rule__PrimaryExpression__Group_2_1__0__Impl : ( ( rule__PrimaryExpression__OperatorAssignment_2_1_0 ) ) ; |
| public final void rule__PrimaryExpression__Group_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5878:1: ( ( ( rule__PrimaryExpression__OperatorAssignment_2_1_0 ) ) ) |
| // InternalSEW.g:5879:1: ( ( rule__PrimaryExpression__OperatorAssignment_2_1_0 ) ) |
| { |
| // InternalSEW.g:5879:1: ( ( rule__PrimaryExpression__OperatorAssignment_2_1_0 ) ) |
| // InternalSEW.g:5880:2: ( rule__PrimaryExpression__OperatorAssignment_2_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getOperatorAssignment_2_1_0()); |
| } |
| // InternalSEW.g:5881:2: ( rule__PrimaryExpression__OperatorAssignment_2_1_0 ) |
| // InternalSEW.g:5881:3: rule__PrimaryExpression__OperatorAssignment_2_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__OperatorAssignment_2_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getOperatorAssignment_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_2_1__1" |
| // InternalSEW.g:5889:1: rule__PrimaryExpression__Group_2_1__1 : rule__PrimaryExpression__Group_2_1__1__Impl ; |
| public final void rule__PrimaryExpression__Group_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5893:1: ( rule__PrimaryExpression__Group_2_1__1__Impl ) |
| // InternalSEW.g:5894:2: rule__PrimaryExpression__Group_2_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_2_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_2_1__1" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_2_1__1__Impl" |
| // InternalSEW.g:5900:1: rule__PrimaryExpression__Group_2_1__1__Impl : ( ( rule__PrimaryExpression__OperandAssignment_2_1_1 ) ) ; |
| public final void rule__PrimaryExpression__Group_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5904:1: ( ( ( rule__PrimaryExpression__OperandAssignment_2_1_1 ) ) ) |
| // InternalSEW.g:5905:1: ( ( rule__PrimaryExpression__OperandAssignment_2_1_1 ) ) |
| { |
| // InternalSEW.g:5905:1: ( ( rule__PrimaryExpression__OperandAssignment_2_1_1 ) ) |
| // InternalSEW.g:5906:2: ( rule__PrimaryExpression__OperandAssignment_2_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getOperandAssignment_2_1_1()); |
| } |
| // InternalSEW.g:5907:2: ( rule__PrimaryExpression__OperandAssignment_2_1_1 ) |
| // InternalSEW.g:5907:3: rule__PrimaryExpression__OperandAssignment_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__OperandAssignment_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getOperandAssignment_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_3__0" |
| // InternalSEW.g:5916:1: rule__PrimaryExpression__Group_3__0 : rule__PrimaryExpression__Group_3__0__Impl rule__PrimaryExpression__Group_3__1 ; |
| public final void rule__PrimaryExpression__Group_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5920:1: ( rule__PrimaryExpression__Group_3__0__Impl rule__PrimaryExpression__Group_3__1 ) |
| // InternalSEW.g:5921:2: rule__PrimaryExpression__Group_3__0__Impl rule__PrimaryExpression__Group_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__PrimaryExpression__Group_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_3__0" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_3__0__Impl" |
| // InternalSEW.g:5928:1: rule__PrimaryExpression__Group_3__0__Impl : ( '(' ) ; |
| public final void rule__PrimaryExpression__Group_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5932:1: ( ( '(' ) ) |
| // InternalSEW.g:5933:1: ( '(' ) |
| { |
| // InternalSEW.g:5933:1: ( '(' ) |
| // InternalSEW.g:5934:2: '(' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_3_0()); |
| } |
| match(input,65,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getLeftParenthesisKeyword_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_3__1" |
| // InternalSEW.g:5943:1: rule__PrimaryExpression__Group_3__1 : rule__PrimaryExpression__Group_3__1__Impl rule__PrimaryExpression__Group_3__2 ; |
| public final void rule__PrimaryExpression__Group_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5947:1: ( rule__PrimaryExpression__Group_3__1__Impl rule__PrimaryExpression__Group_3__2 ) |
| // InternalSEW.g:5948:2: rule__PrimaryExpression__Group_3__1__Impl rule__PrimaryExpression__Group_3__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_44); |
| rule__PrimaryExpression__Group_3__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_3__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_3__1" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_3__1__Impl" |
| // InternalSEW.g:5955:1: rule__PrimaryExpression__Group_3__1__Impl : ( ruleExpression ) ; |
| public final void rule__PrimaryExpression__Group_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5959:1: ( ( ruleExpression ) ) |
| // InternalSEW.g:5960:1: ( ruleExpression ) |
| { |
| // InternalSEW.g:5960:1: ( ruleExpression ) |
| // InternalSEW.g:5961:2: ruleExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getExpressionParserRuleCall_3_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getExpressionParserRuleCall_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_3__2" |
| // InternalSEW.g:5970:1: rule__PrimaryExpression__Group_3__2 : rule__PrimaryExpression__Group_3__2__Impl ; |
| public final void rule__PrimaryExpression__Group_3__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5974:1: ( rule__PrimaryExpression__Group_3__2__Impl ) |
| // InternalSEW.g:5975:2: rule__PrimaryExpression__Group_3__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_3__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_3__2" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__Group_3__2__Impl" |
| // InternalSEW.g:5981:1: rule__PrimaryExpression__Group_3__2__Impl : ( ')' ) ; |
| public final void rule__PrimaryExpression__Group_3__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:5985:1: ( ( ')' ) ) |
| // InternalSEW.g:5986:1: ( ')' ) |
| { |
| // InternalSEW.g:5986:1: ( ')' ) |
| // InternalSEW.g:5987:2: ')' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_3_2()); |
| } |
| match(input,66,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getRightParenthesisKeyword_3_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__Group_3__2__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group__0" |
| // InternalSEW.g:5997:1: rule__LiteralArrayValue__Group__0 : rule__LiteralArrayValue__Group__0__Impl rule__LiteralArrayValue__Group__1 ; |
| public final void rule__LiteralArrayValue__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6001:1: ( rule__LiteralArrayValue__Group__0__Impl rule__LiteralArrayValue__Group__1 ) |
| // InternalSEW.g:6002:2: rule__LiteralArrayValue__Group__0__Impl rule__LiteralArrayValue__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_45); |
| rule__LiteralArrayValue__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group__0__Impl" |
| // InternalSEW.g:6009:1: rule__LiteralArrayValue__Group__0__Impl : ( () ) ; |
| public final void rule__LiteralArrayValue__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6013:1: ( ( () ) ) |
| // InternalSEW.g:6014:1: ( () ) |
| { |
| // InternalSEW.g:6014:1: ( () ) |
| // InternalSEW.g:6015:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueAccess().getLiteralArrayValueAction_0()); |
| } |
| // InternalSEW.g:6016:2: () |
| // InternalSEW.g:6016:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueAccess().getLiteralArrayValueAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group__1" |
| // InternalSEW.g:6024:1: rule__LiteralArrayValue__Group__1 : rule__LiteralArrayValue__Group__1__Impl rule__LiteralArrayValue__Group__2 ; |
| public final void rule__LiteralArrayValue__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6028:1: ( rule__LiteralArrayValue__Group__1__Impl rule__LiteralArrayValue__Group__2 ) |
| // InternalSEW.g:6029:2: rule__LiteralArrayValue__Group__1__Impl rule__LiteralArrayValue__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_46); |
| rule__LiteralArrayValue__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group__1__Impl" |
| // InternalSEW.g:6036:1: rule__LiteralArrayValue__Group__1__Impl : ( '[' ) ; |
| public final void rule__LiteralArrayValue__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6040:1: ( ( '[' ) ) |
| // InternalSEW.g:6041:1: ( '[' ) |
| { |
| // InternalSEW.g:6041:1: ( '[' ) |
| // InternalSEW.g:6042:2: '[' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueAccess().getLeftSquareBracketKeyword_1()); |
| } |
| match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueAccess().getLeftSquareBracketKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group__2" |
| // InternalSEW.g:6051:1: rule__LiteralArrayValue__Group__2 : rule__LiteralArrayValue__Group__2__Impl rule__LiteralArrayValue__Group__3 ; |
| public final void rule__LiteralArrayValue__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6055:1: ( rule__LiteralArrayValue__Group__2__Impl rule__LiteralArrayValue__Group__3 ) |
| // InternalSEW.g:6056:2: rule__LiteralArrayValue__Group__2__Impl rule__LiteralArrayValue__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_46); |
| rule__LiteralArrayValue__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group__2" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group__2__Impl" |
| // InternalSEW.g:6063:1: rule__LiteralArrayValue__Group__2__Impl : ( ( rule__LiteralArrayValue__Group_2__0 )? ) ; |
| public final void rule__LiteralArrayValue__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6067:1: ( ( ( rule__LiteralArrayValue__Group_2__0 )? ) ) |
| // InternalSEW.g:6068:1: ( ( rule__LiteralArrayValue__Group_2__0 )? ) |
| { |
| // InternalSEW.g:6068:1: ( ( rule__LiteralArrayValue__Group_2__0 )? ) |
| // InternalSEW.g:6069:2: ( rule__LiteralArrayValue__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueAccess().getGroup_2()); |
| } |
| // InternalSEW.g:6070:2: ( rule__LiteralArrayValue__Group_2__0 )? |
| int alt77=2; |
| int LA77_0 = input.LA(1); |
| |
| if ( ((LA77_0>=RULE_CHARACTER && LA77_0<=RULE_XIDENDIFIER)||LA77_0==RULE_INT||LA77_0==14||LA77_0==18||LA77_0==20||(LA77_0>=36 && LA77_0<=47)||LA77_0==55||LA77_0==60||LA77_0==65||(LA77_0>=67 && LA77_0<=69)||LA77_0==72||(LA77_0>=74 && LA77_0<=80)) ) { |
| alt77=1; |
| } |
| switch (alt77) { |
| case 1 : |
| // InternalSEW.g:6070:3: rule__LiteralArrayValue__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group__3" |
| // InternalSEW.g:6078:1: rule__LiteralArrayValue__Group__3 : rule__LiteralArrayValue__Group__3__Impl ; |
| public final void rule__LiteralArrayValue__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6082:1: ( rule__LiteralArrayValue__Group__3__Impl ) |
| // InternalSEW.g:6083:2: rule__LiteralArrayValue__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group__3" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group__3__Impl" |
| // InternalSEW.g:6089:1: rule__LiteralArrayValue__Group__3__Impl : ( ']' ) ; |
| public final void rule__LiteralArrayValue__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6093:1: ( ( ']' ) ) |
| // InternalSEW.g:6094:1: ( ']' ) |
| { |
| // InternalSEW.g:6094:1: ( ']' ) |
| // InternalSEW.g:6095:2: ']' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueAccess().getRightSquareBracketKeyword_3()); |
| } |
| match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueAccess().getRightSquareBracketKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group_2__0" |
| // InternalSEW.g:6105:1: rule__LiteralArrayValue__Group_2__0 : rule__LiteralArrayValue__Group_2__0__Impl rule__LiteralArrayValue__Group_2__1 ; |
| public final void rule__LiteralArrayValue__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6109:1: ( rule__LiteralArrayValue__Group_2__0__Impl rule__LiteralArrayValue__Group_2__1 ) |
| // InternalSEW.g:6110:2: rule__LiteralArrayValue__Group_2__0__Impl rule__LiteralArrayValue__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_47); |
| rule__LiteralArrayValue__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group_2__0" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group_2__0__Impl" |
| // InternalSEW.g:6117:1: rule__LiteralArrayValue__Group_2__0__Impl : ( ( rule__LiteralArrayValue__ValuesAssignment_2_0 ) ) ; |
| public final void rule__LiteralArrayValue__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6121:1: ( ( ( rule__LiteralArrayValue__ValuesAssignment_2_0 ) ) ) |
| // InternalSEW.g:6122:1: ( ( rule__LiteralArrayValue__ValuesAssignment_2_0 ) ) |
| { |
| // InternalSEW.g:6122:1: ( ( rule__LiteralArrayValue__ValuesAssignment_2_0 ) ) |
| // InternalSEW.g:6123:2: ( rule__LiteralArrayValue__ValuesAssignment_2_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueAccess().getValuesAssignment_2_0()); |
| } |
| // InternalSEW.g:6124:2: ( rule__LiteralArrayValue__ValuesAssignment_2_0 ) |
| // InternalSEW.g:6124:3: rule__LiteralArrayValue__ValuesAssignment_2_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__ValuesAssignment_2_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueAccess().getValuesAssignment_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group_2__1" |
| // InternalSEW.g:6132:1: rule__LiteralArrayValue__Group_2__1 : rule__LiteralArrayValue__Group_2__1__Impl ; |
| public final void rule__LiteralArrayValue__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6136:1: ( rule__LiteralArrayValue__Group_2__1__Impl ) |
| // InternalSEW.g:6137:2: rule__LiteralArrayValue__Group_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__Group_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group_2__1" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group_2__1__Impl" |
| // InternalSEW.g:6143:1: rule__LiteralArrayValue__Group_2__1__Impl : ( ( rule__LiteralArrayValue__Group_2_1__0 )* ) ; |
| public final void rule__LiteralArrayValue__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6147:1: ( ( ( rule__LiteralArrayValue__Group_2_1__0 )* ) ) |
| // InternalSEW.g:6148:1: ( ( rule__LiteralArrayValue__Group_2_1__0 )* ) |
| { |
| // InternalSEW.g:6148:1: ( ( rule__LiteralArrayValue__Group_2_1__0 )* ) |
| // InternalSEW.g:6149:2: ( rule__LiteralArrayValue__Group_2_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueAccess().getGroup_2_1()); |
| } |
| // InternalSEW.g:6150:2: ( rule__LiteralArrayValue__Group_2_1__0 )* |
| loop78: |
| do { |
| int alt78=2; |
| int LA78_0 = input.LA(1); |
| |
| if ( (LA78_0==53) ) { |
| alt78=1; |
| } |
| |
| |
| switch (alt78) { |
| case 1 : |
| // InternalSEW.g:6150:3: rule__LiteralArrayValue__Group_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_48); |
| rule__LiteralArrayValue__Group_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop78; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueAccess().getGroup_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group_2_1__0" |
| // InternalSEW.g:6159:1: rule__LiteralArrayValue__Group_2_1__0 : rule__LiteralArrayValue__Group_2_1__0__Impl rule__LiteralArrayValue__Group_2_1__1 ; |
| public final void rule__LiteralArrayValue__Group_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6163:1: ( rule__LiteralArrayValue__Group_2_1__0__Impl rule__LiteralArrayValue__Group_2_1__1 ) |
| // InternalSEW.g:6164:2: rule__LiteralArrayValue__Group_2_1__0__Impl rule__LiteralArrayValue__Group_2_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__LiteralArrayValue__Group_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__Group_2_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group_2_1__0" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group_2_1__0__Impl" |
| // InternalSEW.g:6171:1: rule__LiteralArrayValue__Group_2_1__0__Impl : ( ',' ) ; |
| public final void rule__LiteralArrayValue__Group_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6175:1: ( ( ',' ) ) |
| // InternalSEW.g:6176:1: ( ',' ) |
| { |
| // InternalSEW.g:6176:1: ( ',' ) |
| // InternalSEW.g:6177:2: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueAccess().getCommaKeyword_2_1_0()); |
| } |
| match(input,53,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueAccess().getCommaKeyword_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group_2_1__1" |
| // InternalSEW.g:6186:1: rule__LiteralArrayValue__Group_2_1__1 : rule__LiteralArrayValue__Group_2_1__1__Impl ; |
| public final void rule__LiteralArrayValue__Group_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6190:1: ( rule__LiteralArrayValue__Group_2_1__1__Impl ) |
| // InternalSEW.g:6191:2: rule__LiteralArrayValue__Group_2_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__Group_2_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group_2_1__1" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__Group_2_1__1__Impl" |
| // InternalSEW.g:6197:1: rule__LiteralArrayValue__Group_2_1__1__Impl : ( ( rule__LiteralArrayValue__ValuesAssignment_2_1_1 ) ) ; |
| public final void rule__LiteralArrayValue__Group_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6201:1: ( ( ( rule__LiteralArrayValue__ValuesAssignment_2_1_1 ) ) ) |
| // InternalSEW.g:6202:1: ( ( rule__LiteralArrayValue__ValuesAssignment_2_1_1 ) ) |
| { |
| // InternalSEW.g:6202:1: ( ( rule__LiteralArrayValue__ValuesAssignment_2_1_1 ) ) |
| // InternalSEW.g:6203:2: ( rule__LiteralArrayValue__ValuesAssignment_2_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueAccess().getValuesAssignment_2_1_1()); |
| } |
| // InternalSEW.g:6204:2: ( rule__LiteralArrayValue__ValuesAssignment_2_1_1 ) |
| // InternalSEW.g:6204:3: rule__LiteralArrayValue__ValuesAssignment_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralArrayValue__ValuesAssignment_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueAccess().getValuesAssignment_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__Group_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralObjectReference__Group__0" |
| // InternalSEW.g:6213:1: rule__LiteralObjectReference__Group__0 : rule__LiteralObjectReference__Group__0__Impl rule__LiteralObjectReference__Group__1 ; |
| public final void rule__LiteralObjectReference__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6217:1: ( rule__LiteralObjectReference__Group__0__Impl rule__LiteralObjectReference__Group__1 ) |
| // InternalSEW.g:6218:2: rule__LiteralObjectReference__Group__0__Impl rule__LiteralObjectReference__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_49); |
| rule__LiteralObjectReference__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralObjectReference__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralObjectReference__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralObjectReference__Group__0__Impl" |
| // InternalSEW.g:6225:1: rule__LiteralObjectReference__Group__0__Impl : ( ( '&' )? ) ; |
| public final void rule__LiteralObjectReference__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6229:1: ( ( ( '&' )? ) ) |
| // InternalSEW.g:6230:1: ( ( '&' )? ) |
| { |
| // InternalSEW.g:6230:1: ( ( '&' )? ) |
| // InternalSEW.g:6231:2: ( '&' )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralObjectReferenceAccess().getAmpersandKeyword_0()); |
| } |
| // InternalSEW.g:6232:2: ( '&' )? |
| int alt79=2; |
| int LA79_0 = input.LA(1); |
| |
| if ( (LA79_0==67) ) { |
| alt79=1; |
| } |
| switch (alt79) { |
| case 1 : |
| // InternalSEW.g:6232:3: '&' |
| { |
| match(input,67,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralObjectReferenceAccess().getAmpersandKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralObjectReference__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralObjectReference__Group__1" |
| // InternalSEW.g:6240:1: rule__LiteralObjectReference__Group__1 : rule__LiteralObjectReference__Group__1__Impl ; |
| public final void rule__LiteralObjectReference__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6244:1: ( rule__LiteralObjectReference__Group__1__Impl ) |
| // InternalSEW.g:6245:2: rule__LiteralObjectReference__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralObjectReference__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralObjectReference__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralObjectReference__Group__1__Impl" |
| // InternalSEW.g:6251:1: rule__LiteralObjectReference__Group__1__Impl : ( ( rule__LiteralObjectReference__Alternatives_1 ) ) ; |
| public final void rule__LiteralObjectReference__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6255:1: ( ( ( rule__LiteralObjectReference__Alternatives_1 ) ) ) |
| // InternalSEW.g:6256:1: ( ( rule__LiteralObjectReference__Alternatives_1 ) ) |
| { |
| // InternalSEW.g:6256:1: ( ( rule__LiteralObjectReference__Alternatives_1 ) ) |
| // InternalSEW.g:6257:2: ( rule__LiteralObjectReference__Alternatives_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralObjectReferenceAccess().getAlternatives_1()); |
| } |
| // InternalSEW.g:6258:2: ( rule__LiteralObjectReference__Alternatives_1 ) |
| // InternalSEW.g:6258:3: rule__LiteralObjectReference__Alternatives_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralObjectReference__Alternatives_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralObjectReferenceAccess().getAlternatives_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralObjectReference__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralRationalValue__Group__0" |
| // InternalSEW.g:6267:1: rule__LiteralRationalValue__Group__0 : rule__LiteralRationalValue__Group__0__Impl rule__LiteralRationalValue__Group__1 ; |
| public final void rule__LiteralRationalValue__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6271:1: ( rule__LiteralRationalValue__Group__0__Impl rule__LiteralRationalValue__Group__1 ) |
| // InternalSEW.g:6272:2: rule__LiteralRationalValue__Group__0__Impl rule__LiteralRationalValue__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_38); |
| rule__LiteralRationalValue__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralRationalValue__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralRationalValue__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralRationalValue__Group__0__Impl" |
| // InternalSEW.g:6279:1: rule__LiteralRationalValue__Group__0__Impl : ( ( rule__LiteralRationalValue__NumeratorAssignment_0 ) ) ; |
| public final void rule__LiteralRationalValue__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6283:1: ( ( ( rule__LiteralRationalValue__NumeratorAssignment_0 ) ) ) |
| // InternalSEW.g:6284:1: ( ( rule__LiteralRationalValue__NumeratorAssignment_0 ) ) |
| { |
| // InternalSEW.g:6284:1: ( ( rule__LiteralRationalValue__NumeratorAssignment_0 ) ) |
| // InternalSEW.g:6285:2: ( rule__LiteralRationalValue__NumeratorAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralRationalValueAccess().getNumeratorAssignment_0()); |
| } |
| // InternalSEW.g:6286:2: ( rule__LiteralRationalValue__NumeratorAssignment_0 ) |
| // InternalSEW.g:6286:3: rule__LiteralRationalValue__NumeratorAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralRationalValue__NumeratorAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralRationalValueAccess().getNumeratorAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralRationalValue__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralRationalValue__Group__1" |
| // InternalSEW.g:6294:1: rule__LiteralRationalValue__Group__1 : rule__LiteralRationalValue__Group__1__Impl rule__LiteralRationalValue__Group__2 ; |
| public final void rule__LiteralRationalValue__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6298:1: ( rule__LiteralRationalValue__Group__1__Impl rule__LiteralRationalValue__Group__2 ) |
| // InternalSEW.g:6299:2: rule__LiteralRationalValue__Group__1__Impl rule__LiteralRationalValue__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_50); |
| rule__LiteralRationalValue__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralRationalValue__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralRationalValue__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralRationalValue__Group__1__Impl" |
| // InternalSEW.g:6306:1: rule__LiteralRationalValue__Group__1__Impl : ( '/' ) ; |
| public final void rule__LiteralRationalValue__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6310:1: ( ( '/' ) ) |
| // InternalSEW.g:6311:1: ( '/' ) |
| { |
| // InternalSEW.g:6311:1: ( '/' ) |
| // InternalSEW.g:6312:2: '/' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralRationalValueAccess().getSolidusKeyword_1()); |
| } |
| match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralRationalValueAccess().getSolidusKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralRationalValue__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralRationalValue__Group__2" |
| // InternalSEW.g:6321:1: rule__LiteralRationalValue__Group__2 : rule__LiteralRationalValue__Group__2__Impl ; |
| public final void rule__LiteralRationalValue__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6325:1: ( rule__LiteralRationalValue__Group__2__Impl ) |
| // InternalSEW.g:6326:2: rule__LiteralRationalValue__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralRationalValue__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralRationalValue__Group__2" |
| |
| |
| // $ANTLR start "rule__LiteralRationalValue__Group__2__Impl" |
| // InternalSEW.g:6332:1: rule__LiteralRationalValue__Group__2__Impl : ( ( rule__LiteralRationalValue__DenominatorAssignment_2 ) ) ; |
| public final void rule__LiteralRationalValue__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6336:1: ( ( ( rule__LiteralRationalValue__DenominatorAssignment_2 ) ) ) |
| // InternalSEW.g:6337:1: ( ( rule__LiteralRationalValue__DenominatorAssignment_2 ) ) |
| { |
| // InternalSEW.g:6337:1: ( ( rule__LiteralRationalValue__DenominatorAssignment_2 ) ) |
| // InternalSEW.g:6338:2: ( rule__LiteralRationalValue__DenominatorAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralRationalValueAccess().getDenominatorAssignment_2()); |
| } |
| // InternalSEW.g:6339:2: ( rule__LiteralRationalValue__DenominatorAssignment_2 ) |
| // InternalSEW.g:6339:3: rule__LiteralRationalValue__DenominatorAssignment_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralRationalValue__DenominatorAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralRationalValueAccess().getDenominatorAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralRationalValue__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group__0" |
| // InternalSEW.g:6348:1: rule__LiteralNullValue__Group__0 : rule__LiteralNullValue__Group__0__Impl rule__LiteralNullValue__Group__1 ; |
| public final void rule__LiteralNullValue__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6352:1: ( rule__LiteralNullValue__Group__0__Impl rule__LiteralNullValue__Group__1 ) |
| // InternalSEW.g:6353:2: rule__LiteralNullValue__Group__0__Impl rule__LiteralNullValue__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_51); |
| rule__LiteralNullValue__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralNullValue__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group__0__Impl" |
| // InternalSEW.g:6360:1: rule__LiteralNullValue__Group__0__Impl : ( () ) ; |
| public final void rule__LiteralNullValue__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6364:1: ( ( () ) ) |
| // InternalSEW.g:6365:1: ( () ) |
| { |
| // InternalSEW.g:6365:1: ( () ) |
| // InternalSEW.g:6366:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralNullValueAccess().getLiteralNullValueAction_0()); |
| } |
| // InternalSEW.g:6367:2: () |
| // InternalSEW.g:6367:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralNullValueAccess().getLiteralNullValueAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group__1" |
| // InternalSEW.g:6375:1: rule__LiteralNullValue__Group__1 : rule__LiteralNullValue__Group__1__Impl rule__LiteralNullValue__Group__2 ; |
| public final void rule__LiteralNullValue__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6379:1: ( rule__LiteralNullValue__Group__1__Impl rule__LiteralNullValue__Group__2 ) |
| // InternalSEW.g:6380:2: rule__LiteralNullValue__Group__1__Impl rule__LiteralNullValue__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_7); |
| rule__LiteralNullValue__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralNullValue__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group__1__Impl" |
| // InternalSEW.g:6387:1: rule__LiteralNullValue__Group__1__Impl : ( 'null' ) ; |
| public final void rule__LiteralNullValue__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6391:1: ( ( 'null' ) ) |
| // InternalSEW.g:6392:1: ( 'null' ) |
| { |
| // InternalSEW.g:6392:1: ( 'null' ) |
| // InternalSEW.g:6393:2: 'null' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralNullValueAccess().getNullKeyword_1()); |
| } |
| match(input,68,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralNullValueAccess().getNullKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group__2" |
| // InternalSEW.g:6402:1: rule__LiteralNullValue__Group__2 : rule__LiteralNullValue__Group__2__Impl ; |
| public final void rule__LiteralNullValue__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6406:1: ( rule__LiteralNullValue__Group__2__Impl ) |
| // InternalSEW.g:6407:2: rule__LiteralNullValue__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralNullValue__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group__2" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group__2__Impl" |
| // InternalSEW.g:6413:1: rule__LiteralNullValue__Group__2__Impl : ( ( rule__LiteralNullValue__Group_2__0 )? ) ; |
| public final void rule__LiteralNullValue__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6417:1: ( ( ( rule__LiteralNullValue__Group_2__0 )? ) ) |
| // InternalSEW.g:6418:1: ( ( rule__LiteralNullValue__Group_2__0 )? ) |
| { |
| // InternalSEW.g:6418:1: ( ( rule__LiteralNullValue__Group_2__0 )? ) |
| // InternalSEW.g:6419:2: ( rule__LiteralNullValue__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralNullValueAccess().getGroup_2()); |
| } |
| // InternalSEW.g:6420:2: ( rule__LiteralNullValue__Group_2__0 )? |
| int alt80=2; |
| alt80 = dfa80.predict(input); |
| switch (alt80) { |
| case 1 : |
| // InternalSEW.g:6420:3: rule__LiteralNullValue__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralNullValue__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralNullValueAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group_2__0" |
| // InternalSEW.g:6429:1: rule__LiteralNullValue__Group_2__0 : rule__LiteralNullValue__Group_2__0__Impl rule__LiteralNullValue__Group_2__1 ; |
| public final void rule__LiteralNullValue__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6433:1: ( rule__LiteralNullValue__Group_2__0__Impl rule__LiteralNullValue__Group_2__1 ) |
| // InternalSEW.g:6434:2: rule__LiteralNullValue__Group_2__0__Impl rule__LiteralNullValue__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__LiteralNullValue__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralNullValue__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group_2__0" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group_2__0__Impl" |
| // InternalSEW.g:6441:1: rule__LiteralNullValue__Group_2__0__Impl : ( '<' ) ; |
| public final void rule__LiteralNullValue__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6445:1: ( ( '<' ) ) |
| // InternalSEW.g:6446:1: ( '<' ) |
| { |
| // InternalSEW.g:6446:1: ( '<' ) |
| // InternalSEW.g:6447:2: '<' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralNullValueAccess().getLessThanSignKeyword_2_0()); |
| } |
| match(input,32,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralNullValueAccess().getLessThanSignKeyword_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group_2__1" |
| // InternalSEW.g:6456:1: rule__LiteralNullValue__Group_2__1 : rule__LiteralNullValue__Group_2__1__Impl rule__LiteralNullValue__Group_2__2 ; |
| public final void rule__LiteralNullValue__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6460:1: ( rule__LiteralNullValue__Group_2__1__Impl rule__LiteralNullValue__Group_2__2 ) |
| // InternalSEW.g:6461:2: rule__LiteralNullValue__Group_2__1__Impl rule__LiteralNullValue__Group_2__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_52); |
| rule__LiteralNullValue__Group_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralNullValue__Group_2__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group_2__1" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group_2__1__Impl" |
| // InternalSEW.g:6468:1: rule__LiteralNullValue__Group_2__1__Impl : ( ( rule__LiteralNullValue__TypeAssignment_2_1 ) ) ; |
| public final void rule__LiteralNullValue__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6472:1: ( ( ( rule__LiteralNullValue__TypeAssignment_2_1 ) ) ) |
| // InternalSEW.g:6473:1: ( ( rule__LiteralNullValue__TypeAssignment_2_1 ) ) |
| { |
| // InternalSEW.g:6473:1: ( ( rule__LiteralNullValue__TypeAssignment_2_1 ) ) |
| // InternalSEW.g:6474:2: ( rule__LiteralNullValue__TypeAssignment_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralNullValueAccess().getTypeAssignment_2_1()); |
| } |
| // InternalSEW.g:6475:2: ( rule__LiteralNullValue__TypeAssignment_2_1 ) |
| // InternalSEW.g:6475:3: rule__LiteralNullValue__TypeAssignment_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralNullValue__TypeAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralNullValueAccess().getTypeAssignment_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group_2__2" |
| // InternalSEW.g:6483:1: rule__LiteralNullValue__Group_2__2 : rule__LiteralNullValue__Group_2__2__Impl ; |
| public final void rule__LiteralNullValue__Group_2__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6487:1: ( rule__LiteralNullValue__Group_2__2__Impl ) |
| // InternalSEW.g:6488:2: rule__LiteralNullValue__Group_2__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralNullValue__Group_2__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group_2__2" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__Group_2__2__Impl" |
| // InternalSEW.g:6494:1: rule__LiteralNullValue__Group_2__2__Impl : ( '>' ) ; |
| public final void rule__LiteralNullValue__Group_2__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6498:1: ( ( '>' ) ) |
| // InternalSEW.g:6499:1: ( '>' ) |
| { |
| // InternalSEW.g:6499:1: ( '>' ) |
| // InternalSEW.g:6500:2: '>' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralNullValueAccess().getGreaterThanSignKeyword_2_2()); |
| } |
| match(input,34,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralNullValueAccess().getGreaterThanSignKeyword_2_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__Group_2__2__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralTimeVariable__Group__0" |
| // InternalSEW.g:6510:1: rule__LiteralTimeVariable__Group__0 : rule__LiteralTimeVariable__Group__0__Impl rule__LiteralTimeVariable__Group__1 ; |
| public final void rule__LiteralTimeVariable__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6514:1: ( rule__LiteralTimeVariable__Group__0__Impl rule__LiteralTimeVariable__Group__1 ) |
| // InternalSEW.g:6515:2: rule__LiteralTimeVariable__Group__0__Impl rule__LiteralTimeVariable__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_53); |
| rule__LiteralTimeVariable__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralTimeVariable__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralTimeVariable__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralTimeVariable__Group__0__Impl" |
| // InternalSEW.g:6522:1: rule__LiteralTimeVariable__Group__0__Impl : ( () ) ; |
| public final void rule__LiteralTimeVariable__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6526:1: ( ( () ) ) |
| // InternalSEW.g:6527:1: ( () ) |
| { |
| // InternalSEW.g:6527:1: ( () ) |
| // InternalSEW.g:6528:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeVariableAccess().getLiteralTimeVariableAction_0()); |
| } |
| // InternalSEW.g:6529:2: () |
| // InternalSEW.g:6529:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeVariableAccess().getLiteralTimeVariableAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralTimeVariable__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralTimeVariable__Group__1" |
| // InternalSEW.g:6537:1: rule__LiteralTimeVariable__Group__1 : rule__LiteralTimeVariable__Group__1__Impl ; |
| public final void rule__LiteralTimeVariable__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6541:1: ( rule__LiteralTimeVariable__Group__1__Impl ) |
| // InternalSEW.g:6542:2: rule__LiteralTimeVariable__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralTimeVariable__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralTimeVariable__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralTimeVariable__Group__1__Impl" |
| // InternalSEW.g:6548:1: rule__LiteralTimeVariable__Group__1__Impl : ( ( rule__LiteralTimeVariable__SymbolAssignment_1 ) ) ; |
| public final void rule__LiteralTimeVariable__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6552:1: ( ( ( rule__LiteralTimeVariable__SymbolAssignment_1 ) ) ) |
| // InternalSEW.g:6553:1: ( ( rule__LiteralTimeVariable__SymbolAssignment_1 ) ) |
| { |
| // InternalSEW.g:6553:1: ( ( rule__LiteralTimeVariable__SymbolAssignment_1 ) ) |
| // InternalSEW.g:6554:2: ( rule__LiteralTimeVariable__SymbolAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeVariableAccess().getSymbolAssignment_1()); |
| } |
| // InternalSEW.g:6555:2: ( rule__LiteralTimeVariable__SymbolAssignment_1 ) |
| // InternalSEW.g:6555:3: rule__LiteralTimeVariable__SymbolAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralTimeVariable__SymbolAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeVariableAccess().getSymbolAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralTimeVariable__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralTimeDeltaVariable__Group__0" |
| // InternalSEW.g:6564:1: rule__LiteralTimeDeltaVariable__Group__0 : rule__LiteralTimeDeltaVariable__Group__0__Impl rule__LiteralTimeDeltaVariable__Group__1 ; |
| public final void rule__LiteralTimeDeltaVariable__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6568:1: ( rule__LiteralTimeDeltaVariable__Group__0__Impl rule__LiteralTimeDeltaVariable__Group__1 ) |
| // InternalSEW.g:6569:2: rule__LiteralTimeDeltaVariable__Group__0__Impl rule__LiteralTimeDeltaVariable__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_54); |
| rule__LiteralTimeDeltaVariable__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralTimeDeltaVariable__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralTimeDeltaVariable__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralTimeDeltaVariable__Group__0__Impl" |
| // InternalSEW.g:6576:1: rule__LiteralTimeDeltaVariable__Group__0__Impl : ( () ) ; |
| public final void rule__LiteralTimeDeltaVariable__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6580:1: ( ( () ) ) |
| // InternalSEW.g:6581:1: ( () ) |
| { |
| // InternalSEW.g:6581:1: ( () ) |
| // InternalSEW.g:6582:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeDeltaVariableAccess().getLiteralTimeDeltaVariableAction_0()); |
| } |
| // InternalSEW.g:6583:2: () |
| // InternalSEW.g:6583:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeDeltaVariableAccess().getLiteralTimeDeltaVariableAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralTimeDeltaVariable__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralTimeDeltaVariable__Group__1" |
| // InternalSEW.g:6591:1: rule__LiteralTimeDeltaVariable__Group__1 : rule__LiteralTimeDeltaVariable__Group__1__Impl ; |
| public final void rule__LiteralTimeDeltaVariable__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6595:1: ( rule__LiteralTimeDeltaVariable__Group__1__Impl ) |
| // InternalSEW.g:6596:2: rule__LiteralTimeDeltaVariable__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralTimeDeltaVariable__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralTimeDeltaVariable__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralTimeDeltaVariable__Group__1__Impl" |
| // InternalSEW.g:6602:1: rule__LiteralTimeDeltaVariable__Group__1__Impl : ( ( rule__LiteralTimeDeltaVariable__SymbolAssignment_1 ) ) ; |
| public final void rule__LiteralTimeDeltaVariable__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6606:1: ( ( ( rule__LiteralTimeDeltaVariable__SymbolAssignment_1 ) ) ) |
| // InternalSEW.g:6607:1: ( ( rule__LiteralTimeDeltaVariable__SymbolAssignment_1 ) ) |
| { |
| // InternalSEW.g:6607:1: ( ( rule__LiteralTimeDeltaVariable__SymbolAssignment_1 ) ) |
| // InternalSEW.g:6608:2: ( rule__LiteralTimeDeltaVariable__SymbolAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeDeltaVariableAccess().getSymbolAssignment_1()); |
| } |
| // InternalSEW.g:6609:2: ( rule__LiteralTimeDeltaVariable__SymbolAssignment_1 ) |
| // InternalSEW.g:6609:3: rule__LiteralTimeDeltaVariable__SymbolAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralTimeDeltaVariable__SymbolAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeDeltaVariableAccess().getSymbolAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralTimeDeltaVariable__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralThisInstance__Group__0" |
| // InternalSEW.g:6618:1: rule__LiteralThisInstance__Group__0 : rule__LiteralThisInstance__Group__0__Impl rule__LiteralThisInstance__Group__1 ; |
| public final void rule__LiteralThisInstance__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6622:1: ( rule__LiteralThisInstance__Group__0__Impl rule__LiteralThisInstance__Group__1 ) |
| // InternalSEW.g:6623:2: rule__LiteralThisInstance__Group__0__Impl rule__LiteralThisInstance__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_55); |
| rule__LiteralThisInstance__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralThisInstance__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralThisInstance__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralThisInstance__Group__0__Impl" |
| // InternalSEW.g:6630:1: rule__LiteralThisInstance__Group__0__Impl : ( () ) ; |
| public final void rule__LiteralThisInstance__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6634:1: ( ( () ) ) |
| // InternalSEW.g:6635:1: ( () ) |
| { |
| // InternalSEW.g:6635:1: ( () ) |
| // InternalSEW.g:6636:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralThisInstanceAccess().getLiteralThisInstanceAction_0()); |
| } |
| // InternalSEW.g:6637:2: () |
| // InternalSEW.g:6637:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralThisInstanceAccess().getLiteralThisInstanceAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralThisInstance__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralThisInstance__Group__1" |
| // InternalSEW.g:6645:1: rule__LiteralThisInstance__Group__1 : rule__LiteralThisInstance__Group__1__Impl ; |
| public final void rule__LiteralThisInstance__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6649:1: ( rule__LiteralThisInstance__Group__1__Impl ) |
| // InternalSEW.g:6650:2: rule__LiteralThisInstance__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralThisInstance__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralThisInstance__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralThisInstance__Group__1__Impl" |
| // InternalSEW.g:6656:1: rule__LiteralThisInstance__Group__1__Impl : ( ( rule__LiteralThisInstance__SymbolAssignment_1 ) ) ; |
| public final void rule__LiteralThisInstance__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6660:1: ( ( ( rule__LiteralThisInstance__SymbolAssignment_1 ) ) ) |
| // InternalSEW.g:6661:1: ( ( rule__LiteralThisInstance__SymbolAssignment_1 ) ) |
| { |
| // InternalSEW.g:6661:1: ( ( rule__LiteralThisInstance__SymbolAssignment_1 ) ) |
| // InternalSEW.g:6662:2: ( rule__LiteralThisInstance__SymbolAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralThisInstanceAccess().getSymbolAssignment_1()); |
| } |
| // InternalSEW.g:6663:2: ( rule__LiteralThisInstance__SymbolAssignment_1 ) |
| // InternalSEW.g:6663:3: rule__LiteralThisInstance__SymbolAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralThisInstance__SymbolAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralThisInstanceAccess().getSymbolAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralThisInstance__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralSelfInstance__Group__0" |
| // InternalSEW.g:6672:1: rule__LiteralSelfInstance__Group__0 : rule__LiteralSelfInstance__Group__0__Impl rule__LiteralSelfInstance__Group__1 ; |
| public final void rule__LiteralSelfInstance__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6676:1: ( rule__LiteralSelfInstance__Group__0__Impl rule__LiteralSelfInstance__Group__1 ) |
| // InternalSEW.g:6677:2: rule__LiteralSelfInstance__Group__0__Impl rule__LiteralSelfInstance__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_56); |
| rule__LiteralSelfInstance__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSelfInstance__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSelfInstance__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralSelfInstance__Group__0__Impl" |
| // InternalSEW.g:6684:1: rule__LiteralSelfInstance__Group__0__Impl : ( () ) ; |
| public final void rule__LiteralSelfInstance__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6688:1: ( ( () ) ) |
| // InternalSEW.g:6689:1: ( () ) |
| { |
| // InternalSEW.g:6689:1: ( () ) |
| // InternalSEW.g:6690:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSelfInstanceAccess().getLiteralSelfInstanceAction_0()); |
| } |
| // InternalSEW.g:6691:2: () |
| // InternalSEW.g:6691:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSelfInstanceAccess().getLiteralSelfInstanceAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSelfInstance__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralSelfInstance__Group__1" |
| // InternalSEW.g:6699:1: rule__LiteralSelfInstance__Group__1 : rule__LiteralSelfInstance__Group__1__Impl ; |
| public final void rule__LiteralSelfInstance__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6703:1: ( rule__LiteralSelfInstance__Group__1__Impl ) |
| // InternalSEW.g:6704:2: rule__LiteralSelfInstance__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSelfInstance__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSelfInstance__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralSelfInstance__Group__1__Impl" |
| // InternalSEW.g:6710:1: rule__LiteralSelfInstance__Group__1__Impl : ( ( rule__LiteralSelfInstance__SymbolAssignment_1 ) ) ; |
| public final void rule__LiteralSelfInstance__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6714:1: ( ( ( rule__LiteralSelfInstance__SymbolAssignment_1 ) ) ) |
| // InternalSEW.g:6715:1: ( ( rule__LiteralSelfInstance__SymbolAssignment_1 ) ) |
| { |
| // InternalSEW.g:6715:1: ( ( rule__LiteralSelfInstance__SymbolAssignment_1 ) ) |
| // InternalSEW.g:6716:2: ( rule__LiteralSelfInstance__SymbolAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSelfInstanceAccess().getSymbolAssignment_1()); |
| } |
| // InternalSEW.g:6717:2: ( rule__LiteralSelfInstance__SymbolAssignment_1 ) |
| // InternalSEW.g:6717:3: rule__LiteralSelfInstance__SymbolAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSelfInstance__SymbolAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSelfInstanceAccess().getSymbolAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSelfInstance__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralParentInstance__Group__0" |
| // InternalSEW.g:6726:1: rule__LiteralParentInstance__Group__0 : rule__LiteralParentInstance__Group__0__Impl rule__LiteralParentInstance__Group__1 ; |
| public final void rule__LiteralParentInstance__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6730:1: ( rule__LiteralParentInstance__Group__0__Impl rule__LiteralParentInstance__Group__1 ) |
| // InternalSEW.g:6731:2: rule__LiteralParentInstance__Group__0__Impl rule__LiteralParentInstance__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_57); |
| rule__LiteralParentInstance__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralParentInstance__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralParentInstance__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralParentInstance__Group__0__Impl" |
| // InternalSEW.g:6738:1: rule__LiteralParentInstance__Group__0__Impl : ( () ) ; |
| public final void rule__LiteralParentInstance__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6742:1: ( ( () ) ) |
| // InternalSEW.g:6743:1: ( () ) |
| { |
| // InternalSEW.g:6743:1: ( () ) |
| // InternalSEW.g:6744:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralParentInstanceAccess().getLiteralParentInstanceAction_0()); |
| } |
| // InternalSEW.g:6745:2: () |
| // InternalSEW.g:6745:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralParentInstanceAccess().getLiteralParentInstanceAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralParentInstance__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralParentInstance__Group__1" |
| // InternalSEW.g:6753:1: rule__LiteralParentInstance__Group__1 : rule__LiteralParentInstance__Group__1__Impl ; |
| public final void rule__LiteralParentInstance__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6757:1: ( rule__LiteralParentInstance__Group__1__Impl ) |
| // InternalSEW.g:6758:2: rule__LiteralParentInstance__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralParentInstance__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralParentInstance__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralParentInstance__Group__1__Impl" |
| // InternalSEW.g:6764:1: rule__LiteralParentInstance__Group__1__Impl : ( ( rule__LiteralParentInstance__SymbolAssignment_1 ) ) ; |
| public final void rule__LiteralParentInstance__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6768:1: ( ( ( rule__LiteralParentInstance__SymbolAssignment_1 ) ) ) |
| // InternalSEW.g:6769:1: ( ( rule__LiteralParentInstance__SymbolAssignment_1 ) ) |
| { |
| // InternalSEW.g:6769:1: ( ( rule__LiteralParentInstance__SymbolAssignment_1 ) ) |
| // InternalSEW.g:6770:2: ( rule__LiteralParentInstance__SymbolAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralParentInstanceAccess().getSymbolAssignment_1()); |
| } |
| // InternalSEW.g:6771:2: ( rule__LiteralParentInstance__SymbolAssignment_1 ) |
| // InternalSEW.g:6771:3: rule__LiteralParentInstance__SymbolAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralParentInstance__SymbolAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralParentInstanceAccess().getSymbolAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralParentInstance__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralSuperInstance__Group__0" |
| // InternalSEW.g:6780:1: rule__LiteralSuperInstance__Group__0 : rule__LiteralSuperInstance__Group__0__Impl rule__LiteralSuperInstance__Group__1 ; |
| public final void rule__LiteralSuperInstance__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6784:1: ( rule__LiteralSuperInstance__Group__0__Impl rule__LiteralSuperInstance__Group__1 ) |
| // InternalSEW.g:6785:2: rule__LiteralSuperInstance__Group__0__Impl rule__LiteralSuperInstance__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_58); |
| rule__LiteralSuperInstance__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSuperInstance__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSuperInstance__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralSuperInstance__Group__0__Impl" |
| // InternalSEW.g:6792:1: rule__LiteralSuperInstance__Group__0__Impl : ( () ) ; |
| public final void rule__LiteralSuperInstance__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6796:1: ( ( () ) ) |
| // InternalSEW.g:6797:1: ( () ) |
| { |
| // InternalSEW.g:6797:1: ( () ) |
| // InternalSEW.g:6798:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSuperInstanceAccess().getLiteralSuperInstanceAction_0()); |
| } |
| // InternalSEW.g:6799:2: () |
| // InternalSEW.g:6799:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSuperInstanceAccess().getLiteralSuperInstanceAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSuperInstance__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralSuperInstance__Group__1" |
| // InternalSEW.g:6807:1: rule__LiteralSuperInstance__Group__1 : rule__LiteralSuperInstance__Group__1__Impl ; |
| public final void rule__LiteralSuperInstance__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6811:1: ( rule__LiteralSuperInstance__Group__1__Impl ) |
| // InternalSEW.g:6812:2: rule__LiteralSuperInstance__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSuperInstance__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSuperInstance__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralSuperInstance__Group__1__Impl" |
| // InternalSEW.g:6818:1: rule__LiteralSuperInstance__Group__1__Impl : ( ( rule__LiteralSuperInstance__SymbolAssignment_1 ) ) ; |
| public final void rule__LiteralSuperInstance__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6822:1: ( ( ( rule__LiteralSuperInstance__SymbolAssignment_1 ) ) ) |
| // InternalSEW.g:6823:1: ( ( rule__LiteralSuperInstance__SymbolAssignment_1 ) ) |
| { |
| // InternalSEW.g:6823:1: ( ( rule__LiteralSuperInstance__SymbolAssignment_1 ) ) |
| // InternalSEW.g:6824:2: ( rule__LiteralSuperInstance__SymbolAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSuperInstanceAccess().getSymbolAssignment_1()); |
| } |
| // InternalSEW.g:6825:2: ( rule__LiteralSuperInstance__SymbolAssignment_1 ) |
| // InternalSEW.g:6825:3: rule__LiteralSuperInstance__SymbolAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSuperInstance__SymbolAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSuperInstanceAccess().getSymbolAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSuperInstance__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralSystemInstance__Group__0" |
| // InternalSEW.g:6834:1: rule__LiteralSystemInstance__Group__0 : rule__LiteralSystemInstance__Group__0__Impl rule__LiteralSystemInstance__Group__1 ; |
| public final void rule__LiteralSystemInstance__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6838:1: ( rule__LiteralSystemInstance__Group__0__Impl rule__LiteralSystemInstance__Group__1 ) |
| // InternalSEW.g:6839:2: rule__LiteralSystemInstance__Group__0__Impl rule__LiteralSystemInstance__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_59); |
| rule__LiteralSystemInstance__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSystemInstance__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSystemInstance__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralSystemInstance__Group__0__Impl" |
| // InternalSEW.g:6846:1: rule__LiteralSystemInstance__Group__0__Impl : ( () ) ; |
| public final void rule__LiteralSystemInstance__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6850:1: ( ( () ) ) |
| // InternalSEW.g:6851:1: ( () ) |
| { |
| // InternalSEW.g:6851:1: ( () ) |
| // InternalSEW.g:6852:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSystemInstanceAccess().getLiteralSystemInstanceAction_0()); |
| } |
| // InternalSEW.g:6853:2: () |
| // InternalSEW.g:6853:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSystemInstanceAccess().getLiteralSystemInstanceAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSystemInstance__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralSystemInstance__Group__1" |
| // InternalSEW.g:6861:1: rule__LiteralSystemInstance__Group__1 : rule__LiteralSystemInstance__Group__1__Impl ; |
| public final void rule__LiteralSystemInstance__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6865:1: ( rule__LiteralSystemInstance__Group__1__Impl ) |
| // InternalSEW.g:6866:2: rule__LiteralSystemInstance__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSystemInstance__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSystemInstance__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralSystemInstance__Group__1__Impl" |
| // InternalSEW.g:6872:1: rule__LiteralSystemInstance__Group__1__Impl : ( ( rule__LiteralSystemInstance__SymbolAssignment_1 ) ) ; |
| public final void rule__LiteralSystemInstance__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6876:1: ( ( ( rule__LiteralSystemInstance__SymbolAssignment_1 ) ) ) |
| // InternalSEW.g:6877:1: ( ( rule__LiteralSystemInstance__SymbolAssignment_1 ) ) |
| { |
| // InternalSEW.g:6877:1: ( ( rule__LiteralSystemInstance__SymbolAssignment_1 ) ) |
| // InternalSEW.g:6878:2: ( rule__LiteralSystemInstance__SymbolAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSystemInstanceAccess().getSymbolAssignment_1()); |
| } |
| // InternalSEW.g:6879:2: ( rule__LiteralSystemInstance__SymbolAssignment_1 ) |
| // InternalSEW.g:6879:3: rule__LiteralSystemInstance__SymbolAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralSystemInstance__SymbolAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSystemInstanceAccess().getSymbolAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSystemInstance__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralEnvInstance__Group__0" |
| // InternalSEW.g:6888:1: rule__LiteralEnvInstance__Group__0 : rule__LiteralEnvInstance__Group__0__Impl rule__LiteralEnvInstance__Group__1 ; |
| public final void rule__LiteralEnvInstance__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6892:1: ( rule__LiteralEnvInstance__Group__0__Impl rule__LiteralEnvInstance__Group__1 ) |
| // InternalSEW.g:6893:2: rule__LiteralEnvInstance__Group__0__Impl rule__LiteralEnvInstance__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__LiteralEnvInstance__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralEnvInstance__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralEnvInstance__Group__0" |
| |
| |
| // $ANTLR start "rule__LiteralEnvInstance__Group__0__Impl" |
| // InternalSEW.g:6900:1: rule__LiteralEnvInstance__Group__0__Impl : ( () ) ; |
| public final void rule__LiteralEnvInstance__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6904:1: ( ( () ) ) |
| // InternalSEW.g:6905:1: ( () ) |
| { |
| // InternalSEW.g:6905:1: ( () ) |
| // InternalSEW.g:6906:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralEnvInstanceAccess().getLiteralEnvInstanceAction_0()); |
| } |
| // InternalSEW.g:6907:2: () |
| // InternalSEW.g:6907:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralEnvInstanceAccess().getLiteralEnvInstanceAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralEnvInstance__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LiteralEnvInstance__Group__1" |
| // InternalSEW.g:6915:1: rule__LiteralEnvInstance__Group__1 : rule__LiteralEnvInstance__Group__1__Impl ; |
| public final void rule__LiteralEnvInstance__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6919:1: ( rule__LiteralEnvInstance__Group__1__Impl ) |
| // InternalSEW.g:6920:2: rule__LiteralEnvInstance__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralEnvInstance__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralEnvInstance__Group__1" |
| |
| |
| // $ANTLR start "rule__LiteralEnvInstance__Group__1__Impl" |
| // InternalSEW.g:6926:1: rule__LiteralEnvInstance__Group__1__Impl : ( ( rule__LiteralEnvInstance__SymbolAssignment_1 ) ) ; |
| public final void rule__LiteralEnvInstance__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6930:1: ( ( ( rule__LiteralEnvInstance__SymbolAssignment_1 ) ) ) |
| // InternalSEW.g:6931:1: ( ( rule__LiteralEnvInstance__SymbolAssignment_1 ) ) |
| { |
| // InternalSEW.g:6931:1: ( ( rule__LiteralEnvInstance__SymbolAssignment_1 ) ) |
| // InternalSEW.g:6932:2: ( rule__LiteralEnvInstance__SymbolAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralEnvInstanceAccess().getSymbolAssignment_1()); |
| } |
| // InternalSEW.g:6933:2: ( rule__LiteralEnvInstance__SymbolAssignment_1 ) |
| // InternalSEW.g:6933:3: rule__LiteralEnvInstance__SymbolAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralEnvInstance__SymbolAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralEnvInstanceAccess().getSymbolAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralEnvInstance__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__ELong__Group__0" |
| // InternalSEW.g:6942:1: rule__ELong__Group__0 : rule__ELong__Group__0__Impl rule__ELong__Group__1 ; |
| public final void rule__ELong__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6946:1: ( rule__ELong__Group__0__Impl rule__ELong__Group__1 ) |
| // InternalSEW.g:6947:2: rule__ELong__Group__0__Impl rule__ELong__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_50); |
| rule__ELong__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ELong__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ELong__Group__0" |
| |
| |
| // $ANTLR start "rule__ELong__Group__0__Impl" |
| // InternalSEW.g:6954:1: rule__ELong__Group__0__Impl : ( ( '-' )? ) ; |
| public final void rule__ELong__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6958:1: ( ( ( '-' )? ) ) |
| // InternalSEW.g:6959:1: ( ( '-' )? ) |
| { |
| // InternalSEW.g:6959:1: ( ( '-' )? ) |
| // InternalSEW.g:6960:2: ( '-' )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getELongAccess().getHyphenMinusKeyword_0()); |
| } |
| // InternalSEW.g:6961:2: ( '-' )? |
| int alt81=2; |
| int LA81_0 = input.LA(1); |
| |
| if ( (LA81_0==69) ) { |
| alt81=1; |
| } |
| switch (alt81) { |
| case 1 : |
| // InternalSEW.g:6961:3: '-' |
| { |
| match(input,69,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getELongAccess().getHyphenMinusKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ELong__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ELong__Group__1" |
| // InternalSEW.g:6969:1: rule__ELong__Group__1 : rule__ELong__Group__1__Impl ; |
| public final void rule__ELong__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6973:1: ( rule__ELong__Group__1__Impl ) |
| // InternalSEW.g:6974:2: rule__ELong__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ELong__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ELong__Group__1" |
| |
| |
| // $ANTLR start "rule__ELong__Group__1__Impl" |
| // InternalSEW.g:6980:1: rule__ELong__Group__1__Impl : ( RULE_INT ) ; |
| public final void rule__ELong__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:6984:1: ( ( RULE_INT ) ) |
| // InternalSEW.g:6985:1: ( RULE_INT ) |
| { |
| // InternalSEW.g:6985:1: ( RULE_INT ) |
| // InternalSEW.g:6986:2: RULE_INT |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getELongAccess().getINTTerminalRuleCall_1()); |
| } |
| match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getELongAccess().getINTTerminalRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ELong__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__EDouble__Group__0" |
| // InternalSEW.g:6996:1: rule__EDouble__Group__0 : rule__EDouble__Group__0__Impl rule__EDouble__Group__1 ; |
| public final void rule__EDouble__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7000:1: ( rule__EDouble__Group__0__Impl rule__EDouble__Group__1 ) |
| // InternalSEW.g:7001:2: rule__EDouble__Group__0__Impl rule__EDouble__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_10); |
| rule__EDouble__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EDouble__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EDouble__Group__0" |
| |
| |
| // $ANTLR start "rule__EDouble__Group__0__Impl" |
| // InternalSEW.g:7008:1: rule__EDouble__Group__0__Impl : ( ( '-' )? ) ; |
| public final void rule__EDouble__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7012:1: ( ( ( '-' )? ) ) |
| // InternalSEW.g:7013:1: ( ( '-' )? ) |
| { |
| // InternalSEW.g:7013:1: ( ( '-' )? ) |
| // InternalSEW.g:7014:2: ( '-' )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEDoubleAccess().getHyphenMinusKeyword_0()); |
| } |
| // InternalSEW.g:7015:2: ( '-' )? |
| int alt82=2; |
| int LA82_0 = input.LA(1); |
| |
| if ( (LA82_0==69) ) { |
| alt82=1; |
| } |
| switch (alt82) { |
| case 1 : |
| // InternalSEW.g:7015:3: '-' |
| { |
| match(input,69,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEDoubleAccess().getHyphenMinusKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EDouble__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__EDouble__Group__1" |
| // InternalSEW.g:7023:1: rule__EDouble__Group__1 : rule__EDouble__Group__1__Impl rule__EDouble__Group__2 ; |
| public final void rule__EDouble__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7027:1: ( rule__EDouble__Group__1__Impl rule__EDouble__Group__2 ) |
| // InternalSEW.g:7028:2: rule__EDouble__Group__1__Impl rule__EDouble__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_10); |
| rule__EDouble__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EDouble__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EDouble__Group__1" |
| |
| |
| // $ANTLR start "rule__EDouble__Group__1__Impl" |
| // InternalSEW.g:7035:1: rule__EDouble__Group__1__Impl : ( ( RULE_INT )? ) ; |
| public final void rule__EDouble__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7039:1: ( ( ( RULE_INT )? ) ) |
| // InternalSEW.g:7040:1: ( ( RULE_INT )? ) |
| { |
| // InternalSEW.g:7040:1: ( ( RULE_INT )? ) |
| // InternalSEW.g:7041:2: ( RULE_INT )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEDoubleAccess().getINTTerminalRuleCall_1()); |
| } |
| // InternalSEW.g:7042:2: ( RULE_INT )? |
| int alt83=2; |
| int LA83_0 = input.LA(1); |
| |
| if ( (LA83_0==RULE_INT) ) { |
| alt83=1; |
| } |
| switch (alt83) { |
| case 1 : |
| // InternalSEW.g:7042:3: RULE_INT |
| { |
| match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEDoubleAccess().getINTTerminalRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EDouble__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__EDouble__Group__2" |
| // InternalSEW.g:7050:1: rule__EDouble__Group__2 : rule__EDouble__Group__2__Impl rule__EDouble__Group__3 ; |
| public final void rule__EDouble__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7054:1: ( rule__EDouble__Group__2__Impl rule__EDouble__Group__3 ) |
| // InternalSEW.g:7055:2: rule__EDouble__Group__2__Impl rule__EDouble__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_60); |
| rule__EDouble__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EDouble__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EDouble__Group__2" |
| |
| |
| // $ANTLR start "rule__EDouble__Group__2__Impl" |
| // InternalSEW.g:7062:1: rule__EDouble__Group__2__Impl : ( '.' ) ; |
| public final void rule__EDouble__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7066:1: ( ( '.' ) ) |
| // InternalSEW.g:7067:1: ( '.' ) |
| { |
| // InternalSEW.g:7067:1: ( '.' ) |
| // InternalSEW.g:7068:2: '.' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEDoubleAccess().getFullStopKeyword_2()); |
| } |
| match(input,20,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEDoubleAccess().getFullStopKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EDouble__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__EDouble__Group__3" |
| // InternalSEW.g:7077:1: rule__EDouble__Group__3 : rule__EDouble__Group__3__Impl ; |
| public final void rule__EDouble__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7081:1: ( rule__EDouble__Group__3__Impl ) |
| // InternalSEW.g:7082:2: rule__EDouble__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EDouble__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EDouble__Group__3" |
| |
| |
| // $ANTLR start "rule__EDouble__Group__3__Impl" |
| // InternalSEW.g:7088:1: rule__EDouble__Group__3__Impl : ( RULE_INT ) ; |
| public final void rule__EDouble__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7092:1: ( ( RULE_INT ) ) |
| // InternalSEW.g:7093:1: ( RULE_INT ) |
| { |
| // InternalSEW.g:7093:1: ( RULE_INT ) |
| // InternalSEW.g:7094:2: RULE_INT |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEDoubleAccess().getINTTerminalRuleCall_3()); |
| } |
| match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEDoubleAccess().getINTTerminalRuleCall_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EDouble__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__EBigDecimal__Group__0" |
| // InternalSEW.g:7104:1: rule__EBigDecimal__Group__0 : rule__EBigDecimal__Group__0__Impl rule__EBigDecimal__Group__1 ; |
| public final void rule__EBigDecimal__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7108:1: ( rule__EBigDecimal__Group__0__Impl rule__EBigDecimal__Group__1 ) |
| // InternalSEW.g:7109:2: rule__EBigDecimal__Group__0__Impl rule__EBigDecimal__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_61); |
| rule__EBigDecimal__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EBigDecimal__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EBigDecimal__Group__0" |
| |
| |
| // $ANTLR start "rule__EBigDecimal__Group__0__Impl" |
| // InternalSEW.g:7116:1: rule__EBigDecimal__Group__0__Impl : ( ( RULE_INT )? ) ; |
| public final void rule__EBigDecimal__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7120:1: ( ( ( RULE_INT )? ) ) |
| // InternalSEW.g:7121:1: ( ( RULE_INT )? ) |
| { |
| // InternalSEW.g:7121:1: ( ( RULE_INT )? ) |
| // InternalSEW.g:7122:2: ( RULE_INT )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEBigDecimalAccess().getINTTerminalRuleCall_0()); |
| } |
| // InternalSEW.g:7123:2: ( RULE_INT )? |
| int alt84=2; |
| int LA84_0 = input.LA(1); |
| |
| if ( (LA84_0==RULE_INT) ) { |
| alt84=1; |
| } |
| switch (alt84) { |
| case 1 : |
| // InternalSEW.g:7123:3: RULE_INT |
| { |
| match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEBigDecimalAccess().getINTTerminalRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EBigDecimal__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__EBigDecimal__Group__1" |
| // InternalSEW.g:7131:1: rule__EBigDecimal__Group__1 : rule__EBigDecimal__Group__1__Impl rule__EBigDecimal__Group__2 ; |
| public final void rule__EBigDecimal__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7135:1: ( rule__EBigDecimal__Group__1__Impl rule__EBigDecimal__Group__2 ) |
| // InternalSEW.g:7136:2: rule__EBigDecimal__Group__1__Impl rule__EBigDecimal__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_60); |
| rule__EBigDecimal__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EBigDecimal__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EBigDecimal__Group__1" |
| |
| |
| // $ANTLR start "rule__EBigDecimal__Group__1__Impl" |
| // InternalSEW.g:7143:1: rule__EBigDecimal__Group__1__Impl : ( '.' ) ; |
| public final void rule__EBigDecimal__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7147:1: ( ( '.' ) ) |
| // InternalSEW.g:7148:1: ( '.' ) |
| { |
| // InternalSEW.g:7148:1: ( '.' ) |
| // InternalSEW.g:7149:2: '.' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEBigDecimalAccess().getFullStopKeyword_1()); |
| } |
| match(input,20,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEBigDecimalAccess().getFullStopKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EBigDecimal__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__EBigDecimal__Group__2" |
| // InternalSEW.g:7158:1: rule__EBigDecimal__Group__2 : rule__EBigDecimal__Group__2__Impl ; |
| public final void rule__EBigDecimal__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7162:1: ( rule__EBigDecimal__Group__2__Impl ) |
| // InternalSEW.g:7163:2: rule__EBigDecimal__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EBigDecimal__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EBigDecimal__Group__2" |
| |
| |
| // $ANTLR start "rule__EBigDecimal__Group__2__Impl" |
| // InternalSEW.g:7169:1: rule__EBigDecimal__Group__2__Impl : ( RULE_INT ) ; |
| public final void rule__EBigDecimal__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7173:1: ( ( RULE_INT ) ) |
| // InternalSEW.g:7174:1: ( RULE_INT ) |
| { |
| // InternalSEW.g:7174:1: ( RULE_INT ) |
| // InternalSEW.g:7175:2: RULE_INT |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEBigDecimalAccess().getINTTerminalRuleCall_2()); |
| } |
| match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEBigDecimalAccess().getINTTerminalRuleCall_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EBigDecimal__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__0" |
| // InternalSEW.g:7185:1: rule__DeprecatedObject__Group_0__0 : rule__DeprecatedObject__Group_0__0__Impl rule__DeprecatedObject__Group_0__1 ; |
| public final void rule__DeprecatedObject__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7189:1: ( rule__DeprecatedObject__Group_0__0__Impl rule__DeprecatedObject__Group_0__1 ) |
| // InternalSEW.g:7190:2: rule__DeprecatedObject__Group_0__0__Impl rule__DeprecatedObject__Group_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_62); |
| rule__DeprecatedObject__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__0" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__0__Impl" |
| // InternalSEW.g:7197:1: rule__DeprecatedObject__Group_0__0__Impl : ( () ) ; |
| public final void rule__DeprecatedObject__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7201:1: ( ( () ) ) |
| // InternalSEW.g:7202:1: ( () ) |
| { |
| // InternalSEW.g:7202:1: ( () ) |
| // InternalSEW.g:7203:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getWObjectAction_0_0()); |
| } |
| // InternalSEW.g:7204:2: () |
| // InternalSEW.g:7204:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getWObjectAction_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__1" |
| // InternalSEW.g:7212:1: rule__DeprecatedObject__Group_0__1 : rule__DeprecatedObject__Group_0__1__Impl rule__DeprecatedObject__Group_0__2 ; |
| public final void rule__DeprecatedObject__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7216:1: ( rule__DeprecatedObject__Group_0__1__Impl rule__DeprecatedObject__Group_0__2 ) |
| // InternalSEW.g:7217:2: rule__DeprecatedObject__Group_0__1__Impl rule__DeprecatedObject__Group_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__DeprecatedObject__Group_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__1" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__1__Impl" |
| // InternalSEW.g:7224:1: rule__DeprecatedObject__Group_0__1__Impl : ( 'form' ) ; |
| public final void rule__DeprecatedObject__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7228:1: ( ( 'form' ) ) |
| // InternalSEW.g:7229:1: ( 'form' ) |
| { |
| // InternalSEW.g:7229:1: ( 'form' ) |
| // InternalSEW.g:7230:2: 'form' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getFormKeyword_0_1()); |
| } |
| match(input,42,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getFormKeyword_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__2" |
| // InternalSEW.g:7239:1: rule__DeprecatedObject__Group_0__2 : rule__DeprecatedObject__Group_0__2__Impl rule__DeprecatedObject__Group_0__3 ; |
| public final void rule__DeprecatedObject__Group_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7243:1: ( rule__DeprecatedObject__Group_0__2__Impl rule__DeprecatedObject__Group_0__3 ) |
| // InternalSEW.g:7244:2: rule__DeprecatedObject__Group_0__2__Impl rule__DeprecatedObject__Group_0__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_63); |
| rule__DeprecatedObject__Group_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_0__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__2" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__2__Impl" |
| // InternalSEW.g:7251:1: rule__DeprecatedObject__Group_0__2__Impl : ( ( rule__DeprecatedObject__NameAssignment_0_2 ) ) ; |
| public final void rule__DeprecatedObject__Group_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7255:1: ( ( ( rule__DeprecatedObject__NameAssignment_0_2 ) ) ) |
| // InternalSEW.g:7256:1: ( ( rule__DeprecatedObject__NameAssignment_0_2 ) ) |
| { |
| // InternalSEW.g:7256:1: ( ( rule__DeprecatedObject__NameAssignment_0_2 ) ) |
| // InternalSEW.g:7257:2: ( rule__DeprecatedObject__NameAssignment_0_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getNameAssignment_0_2()); |
| } |
| // InternalSEW.g:7258:2: ( rule__DeprecatedObject__NameAssignment_0_2 ) |
| // InternalSEW.g:7258:3: rule__DeprecatedObject__NameAssignment_0_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__NameAssignment_0_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getNameAssignment_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__3" |
| // InternalSEW.g:7266:1: rule__DeprecatedObject__Group_0__3 : rule__DeprecatedObject__Group_0__3__Impl rule__DeprecatedObject__Group_0__4 ; |
| public final void rule__DeprecatedObject__Group_0__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7270:1: ( rule__DeprecatedObject__Group_0__3__Impl rule__DeprecatedObject__Group_0__4 ) |
| // InternalSEW.g:7271:2: rule__DeprecatedObject__Group_0__3__Impl rule__DeprecatedObject__Group_0__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_63); |
| rule__DeprecatedObject__Group_0__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_0__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__3" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__3__Impl" |
| // InternalSEW.g:7278:1: rule__DeprecatedObject__Group_0__3__Impl : ( ( rule__DeprecatedObject__DescriptionAssignment_0_3 )? ) ; |
| public final void rule__DeprecatedObject__Group_0__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7282:1: ( ( ( rule__DeprecatedObject__DescriptionAssignment_0_3 )? ) ) |
| // InternalSEW.g:7283:1: ( ( rule__DeprecatedObject__DescriptionAssignment_0_3 )? ) |
| { |
| // InternalSEW.g:7283:1: ( ( rule__DeprecatedObject__DescriptionAssignment_0_3 )? ) |
| // InternalSEW.g:7284:2: ( rule__DeprecatedObject__DescriptionAssignment_0_3 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getDescriptionAssignment_0_3()); |
| } |
| // InternalSEW.g:7285:2: ( rule__DeprecatedObject__DescriptionAssignment_0_3 )? |
| int alt85=2; |
| int LA85_0 = input.LA(1); |
| |
| if ( (LA85_0==RULE_STRING) ) { |
| alt85=1; |
| } |
| switch (alt85) { |
| case 1 : |
| // InternalSEW.g:7285:3: rule__DeprecatedObject__DescriptionAssignment_0_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__DescriptionAssignment_0_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getDescriptionAssignment_0_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__3__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__4" |
| // InternalSEW.g:7293:1: rule__DeprecatedObject__Group_0__4 : rule__DeprecatedObject__Group_0__4__Impl rule__DeprecatedObject__Group_0__5 ; |
| public final void rule__DeprecatedObject__Group_0__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7297:1: ( rule__DeprecatedObject__Group_0__4__Impl rule__DeprecatedObject__Group_0__5 ) |
| // InternalSEW.g:7298:2: rule__DeprecatedObject__Group_0__4__Impl rule__DeprecatedObject__Group_0__5 |
| { |
| pushFollow(FollowSets000.FOLLOW_49); |
| rule__DeprecatedObject__Group_0__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_0__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__4" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__4__Impl" |
| // InternalSEW.g:7305:1: rule__DeprecatedObject__Group_0__4__Impl : ( 'as' ) ; |
| public final void rule__DeprecatedObject__Group_0__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7309:1: ( ( 'as' ) ) |
| // InternalSEW.g:7310:1: ( 'as' ) |
| { |
| // InternalSEW.g:7310:1: ( 'as' ) |
| // InternalSEW.g:7311:2: 'as' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getAsKeyword_0_4()); |
| } |
| match(input,70,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getAsKeyword_0_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__4__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__5" |
| // InternalSEW.g:7320:1: rule__DeprecatedObject__Group_0__5 : rule__DeprecatedObject__Group_0__5__Impl rule__DeprecatedObject__Group_0__6 ; |
| public final void rule__DeprecatedObject__Group_0__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7324:1: ( rule__DeprecatedObject__Group_0__5__Impl rule__DeprecatedObject__Group_0__6 ) |
| // InternalSEW.g:7325:2: rule__DeprecatedObject__Group_0__5__Impl rule__DeprecatedObject__Group_0__6 |
| { |
| pushFollow(FollowSets000.FOLLOW_49); |
| rule__DeprecatedObject__Group_0__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_0__6(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__5" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__5__Impl" |
| // InternalSEW.g:7332:1: rule__DeprecatedObject__Group_0__5__Impl : ( ( '&' )? ) ; |
| public final void rule__DeprecatedObject__Group_0__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7336:1: ( ( ( '&' )? ) ) |
| // InternalSEW.g:7337:1: ( ( '&' )? ) |
| { |
| // InternalSEW.g:7337:1: ( ( '&' )? ) |
| // InternalSEW.g:7338:2: ( '&' )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getAmpersandKeyword_0_5()); |
| } |
| // InternalSEW.g:7339:2: ( '&' )? |
| int alt86=2; |
| int LA86_0 = input.LA(1); |
| |
| if ( (LA86_0==67) ) { |
| alt86=1; |
| } |
| switch (alt86) { |
| case 1 : |
| // InternalSEW.g:7339:3: '&' |
| { |
| match(input,67,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getAmpersandKeyword_0_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__5__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__6" |
| // InternalSEW.g:7347:1: rule__DeprecatedObject__Group_0__6 : rule__DeprecatedObject__Group_0__6__Impl rule__DeprecatedObject__Group_0__7 ; |
| public final void rule__DeprecatedObject__Group_0__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7351:1: ( rule__DeprecatedObject__Group_0__6__Impl rule__DeprecatedObject__Group_0__7 ) |
| // InternalSEW.g:7352:2: rule__DeprecatedObject__Group_0__6__Impl rule__DeprecatedObject__Group_0__7 |
| { |
| pushFollow(FollowSets000.FOLLOW_64); |
| rule__DeprecatedObject__Group_0__6__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_0__7(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__6" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__6__Impl" |
| // InternalSEW.g:7359:1: rule__DeprecatedObject__Group_0__6__Impl : ( ( rule__DeprecatedObject__TypeAssignment_0_6 ) ) ; |
| public final void rule__DeprecatedObject__Group_0__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7363:1: ( ( ( rule__DeprecatedObject__TypeAssignment_0_6 ) ) ) |
| // InternalSEW.g:7364:1: ( ( rule__DeprecatedObject__TypeAssignment_0_6 ) ) |
| { |
| // InternalSEW.g:7364:1: ( ( rule__DeprecatedObject__TypeAssignment_0_6 ) ) |
| // InternalSEW.g:7365:2: ( rule__DeprecatedObject__TypeAssignment_0_6 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getTypeAssignment_0_6()); |
| } |
| // InternalSEW.g:7366:2: ( rule__DeprecatedObject__TypeAssignment_0_6 ) |
| // InternalSEW.g:7366:3: rule__DeprecatedObject__TypeAssignment_0_6 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__TypeAssignment_0_6(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getTypeAssignment_0_6()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__6__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__7" |
| // InternalSEW.g:7374:1: rule__DeprecatedObject__Group_0__7 : rule__DeprecatedObject__Group_0__7__Impl rule__DeprecatedObject__Group_0__8 ; |
| public final void rule__DeprecatedObject__Group_0__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7378:1: ( rule__DeprecatedObject__Group_0__7__Impl rule__DeprecatedObject__Group_0__8 ) |
| // InternalSEW.g:7379:2: rule__DeprecatedObject__Group_0__7__Impl rule__DeprecatedObject__Group_0__8 |
| { |
| pushFollow(FollowSets000.FOLLOW_65); |
| rule__DeprecatedObject__Group_0__7__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_0__8(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__7" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__7__Impl" |
| // InternalSEW.g:7386:1: rule__DeprecatedObject__Group_0__7__Impl : ( 'is' ) ; |
| public final void rule__DeprecatedObject__Group_0__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7390:1: ( ( 'is' ) ) |
| // InternalSEW.g:7391:1: ( 'is' ) |
| { |
| // InternalSEW.g:7391:1: ( 'is' ) |
| // InternalSEW.g:7392:2: 'is' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getIsKeyword_0_7()); |
| } |
| match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getIsKeyword_0_7()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__7__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__8" |
| // InternalSEW.g:7401:1: rule__DeprecatedObject__Group_0__8 : rule__DeprecatedObject__Group_0__8__Impl rule__DeprecatedObject__Group_0__9 ; |
| public final void rule__DeprecatedObject__Group_0__8() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7405:1: ( rule__DeprecatedObject__Group_0__8__Impl rule__DeprecatedObject__Group_0__9 ) |
| // InternalSEW.g:7406:2: rule__DeprecatedObject__Group_0__8__Impl rule__DeprecatedObject__Group_0__9 |
| { |
| pushFollow(FollowSets000.FOLLOW_65); |
| rule__DeprecatedObject__Group_0__8__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_0__9(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__8" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__8__Impl" |
| // InternalSEW.g:7413:1: rule__DeprecatedObject__Group_0__8__Impl : ( ( rule__DeprecatedObject__ElementAssignment_0_8 )* ) ; |
| public final void rule__DeprecatedObject__Group_0__8__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7417:1: ( ( ( rule__DeprecatedObject__ElementAssignment_0_8 )* ) ) |
| // InternalSEW.g:7418:1: ( ( rule__DeprecatedObject__ElementAssignment_0_8 )* ) |
| { |
| // InternalSEW.g:7418:1: ( ( rule__DeprecatedObject__ElementAssignment_0_8 )* ) |
| // InternalSEW.g:7419:2: ( rule__DeprecatedObject__ElementAssignment_0_8 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getElementAssignment_0_8()); |
| } |
| // InternalSEW.g:7420:2: ( rule__DeprecatedObject__ElementAssignment_0_8 )* |
| loop87: |
| do { |
| int alt87=2; |
| int LA87_0 = input.LA(1); |
| |
| if ( (LA87_0==43) ) { |
| int LA87_1 = input.LA(2); |
| |
| if ( (LA87_1==RULE_STRING||LA87_1==55||(LA87_1>=57 && LA87_1<=58)) ) { |
| alt87=1; |
| } |
| |
| |
| } |
| else if ( ((LA87_0>=RULE_XIDENDIFIER && LA87_0<=RULE_AT_IDENTIFIER)||LA87_0==14||LA87_0==18||LA87_0==42||(LA87_0>=44 && LA87_0<=47)) ) { |
| alt87=1; |
| } |
| |
| |
| switch (alt87) { |
| case 1 : |
| // InternalSEW.g:7420:3: rule__DeprecatedObject__ElementAssignment_0_8 |
| { |
| pushFollow(FollowSets000.FOLLOW_66); |
| rule__DeprecatedObject__ElementAssignment_0_8(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop87; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getElementAssignment_0_8()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__8__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__9" |
| // InternalSEW.g:7428:1: rule__DeprecatedObject__Group_0__9 : rule__DeprecatedObject__Group_0__9__Impl ; |
| public final void rule__DeprecatedObject__Group_0__9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7432:1: ( rule__DeprecatedObject__Group_0__9__Impl ) |
| // InternalSEW.g:7433:2: rule__DeprecatedObject__Group_0__9__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_0__9__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__9" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_0__9__Impl" |
| // InternalSEW.g:7439:1: rule__DeprecatedObject__Group_0__9__Impl : ( 'endform' ) ; |
| public final void rule__DeprecatedObject__Group_0__9__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7443:1: ( ( 'endform' ) ) |
| // InternalSEW.g:7444:1: ( 'endform' ) |
| { |
| // InternalSEW.g:7444:1: ( 'endform' ) |
| // InternalSEW.g:7445:2: 'endform' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getEndformKeyword_0_9()); |
| } |
| match(input,43,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getEndformKeyword_0_9()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_0__9__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__0" |
| // InternalSEW.g:7455:1: rule__DeprecatedObject__Group_1__0 : rule__DeprecatedObject__Group_1__0__Impl rule__DeprecatedObject__Group_1__1 ; |
| public final void rule__DeprecatedObject__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7459:1: ( rule__DeprecatedObject__Group_1__0__Impl rule__DeprecatedObject__Group_1__1 ) |
| // InternalSEW.g:7460:2: rule__DeprecatedObject__Group_1__0__Impl rule__DeprecatedObject__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_4); |
| rule__DeprecatedObject__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__0" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__0__Impl" |
| // InternalSEW.g:7467:1: rule__DeprecatedObject__Group_1__0__Impl : ( () ) ; |
| public final void rule__DeprecatedObject__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7471:1: ( ( () ) ) |
| // InternalSEW.g:7472:1: ( () ) |
| { |
| // InternalSEW.g:7472:1: ( () ) |
| // InternalSEW.g:7473:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getWObjectAction_1_0()); |
| } |
| // InternalSEW.g:7474:2: () |
| // InternalSEW.g:7474:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getWObjectAction_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__1" |
| // InternalSEW.g:7482:1: rule__DeprecatedObject__Group_1__1 : rule__DeprecatedObject__Group_1__1__Impl rule__DeprecatedObject__Group_1__2 ; |
| public final void rule__DeprecatedObject__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7486:1: ( rule__DeprecatedObject__Group_1__1__Impl rule__DeprecatedObject__Group_1__2 ) |
| // InternalSEW.g:7487:2: rule__DeprecatedObject__Group_1__1__Impl rule__DeprecatedObject__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__DeprecatedObject__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__1" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__1__Impl" |
| // InternalSEW.g:7494:1: rule__DeprecatedObject__Group_1__1__Impl : ( 'prototype' ) ; |
| public final void rule__DeprecatedObject__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7498:1: ( ( 'prototype' ) ) |
| // InternalSEW.g:7499:1: ( 'prototype' ) |
| { |
| // InternalSEW.g:7499:1: ( 'prototype' ) |
| // InternalSEW.g:7500:2: 'prototype' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getPrototypeKeyword_1_1()); |
| } |
| match(input,44,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getPrototypeKeyword_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__2" |
| // InternalSEW.g:7509:1: rule__DeprecatedObject__Group_1__2 : rule__DeprecatedObject__Group_1__2__Impl rule__DeprecatedObject__Group_1__3 ; |
| public final void rule__DeprecatedObject__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7513:1: ( rule__DeprecatedObject__Group_1__2__Impl rule__DeprecatedObject__Group_1__3 ) |
| // InternalSEW.g:7514:2: rule__DeprecatedObject__Group_1__2__Impl rule__DeprecatedObject__Group_1__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_63); |
| rule__DeprecatedObject__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__2" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__2__Impl" |
| // InternalSEW.g:7521:1: rule__DeprecatedObject__Group_1__2__Impl : ( ( rule__DeprecatedObject__NameAssignment_1_2 ) ) ; |
| public final void rule__DeprecatedObject__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7525:1: ( ( ( rule__DeprecatedObject__NameAssignment_1_2 ) ) ) |
| // InternalSEW.g:7526:1: ( ( rule__DeprecatedObject__NameAssignment_1_2 ) ) |
| { |
| // InternalSEW.g:7526:1: ( ( rule__DeprecatedObject__NameAssignment_1_2 ) ) |
| // InternalSEW.g:7527:2: ( rule__DeprecatedObject__NameAssignment_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getNameAssignment_1_2()); |
| } |
| // InternalSEW.g:7528:2: ( rule__DeprecatedObject__NameAssignment_1_2 ) |
| // InternalSEW.g:7528:3: rule__DeprecatedObject__NameAssignment_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__NameAssignment_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getNameAssignment_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__3" |
| // InternalSEW.g:7536:1: rule__DeprecatedObject__Group_1__3 : rule__DeprecatedObject__Group_1__3__Impl rule__DeprecatedObject__Group_1__4 ; |
| public final void rule__DeprecatedObject__Group_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7540:1: ( rule__DeprecatedObject__Group_1__3__Impl rule__DeprecatedObject__Group_1__4 ) |
| // InternalSEW.g:7541:2: rule__DeprecatedObject__Group_1__3__Impl rule__DeprecatedObject__Group_1__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_63); |
| rule__DeprecatedObject__Group_1__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_1__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__3" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__3__Impl" |
| // InternalSEW.g:7548:1: rule__DeprecatedObject__Group_1__3__Impl : ( ( rule__DeprecatedObject__DescriptionAssignment_1_3 )? ) ; |
| public final void rule__DeprecatedObject__Group_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7552:1: ( ( ( rule__DeprecatedObject__DescriptionAssignment_1_3 )? ) ) |
| // InternalSEW.g:7553:1: ( ( rule__DeprecatedObject__DescriptionAssignment_1_3 )? ) |
| { |
| // InternalSEW.g:7553:1: ( ( rule__DeprecatedObject__DescriptionAssignment_1_3 )? ) |
| // InternalSEW.g:7554:2: ( rule__DeprecatedObject__DescriptionAssignment_1_3 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getDescriptionAssignment_1_3()); |
| } |
| // InternalSEW.g:7555:2: ( rule__DeprecatedObject__DescriptionAssignment_1_3 )? |
| int alt88=2; |
| int LA88_0 = input.LA(1); |
| |
| if ( (LA88_0==RULE_STRING) ) { |
| alt88=1; |
| } |
| switch (alt88) { |
| case 1 : |
| // InternalSEW.g:7555:3: rule__DeprecatedObject__DescriptionAssignment_1_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__DescriptionAssignment_1_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getDescriptionAssignment_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__4" |
| // InternalSEW.g:7563:1: rule__DeprecatedObject__Group_1__4 : rule__DeprecatedObject__Group_1__4__Impl rule__DeprecatedObject__Group_1__5 ; |
| public final void rule__DeprecatedObject__Group_1__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7567:1: ( rule__DeprecatedObject__Group_1__4__Impl rule__DeprecatedObject__Group_1__5 ) |
| // InternalSEW.g:7568:2: rule__DeprecatedObject__Group_1__4__Impl rule__DeprecatedObject__Group_1__5 |
| { |
| pushFollow(FollowSets000.FOLLOW_49); |
| rule__DeprecatedObject__Group_1__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_1__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__4" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__4__Impl" |
| // InternalSEW.g:7575:1: rule__DeprecatedObject__Group_1__4__Impl : ( 'as' ) ; |
| public final void rule__DeprecatedObject__Group_1__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7579:1: ( ( 'as' ) ) |
| // InternalSEW.g:7580:1: ( 'as' ) |
| { |
| // InternalSEW.g:7580:1: ( 'as' ) |
| // InternalSEW.g:7581:2: 'as' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getAsKeyword_1_4()); |
| } |
| match(input,70,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getAsKeyword_1_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__4__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__5" |
| // InternalSEW.g:7590:1: rule__DeprecatedObject__Group_1__5 : rule__DeprecatedObject__Group_1__5__Impl rule__DeprecatedObject__Group_1__6 ; |
| public final void rule__DeprecatedObject__Group_1__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7594:1: ( rule__DeprecatedObject__Group_1__5__Impl rule__DeprecatedObject__Group_1__6 ) |
| // InternalSEW.g:7595:2: rule__DeprecatedObject__Group_1__5__Impl rule__DeprecatedObject__Group_1__6 |
| { |
| pushFollow(FollowSets000.FOLLOW_49); |
| rule__DeprecatedObject__Group_1__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_1__6(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__5" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__5__Impl" |
| // InternalSEW.g:7602:1: rule__DeprecatedObject__Group_1__5__Impl : ( ( '&' )? ) ; |
| public final void rule__DeprecatedObject__Group_1__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7606:1: ( ( ( '&' )? ) ) |
| // InternalSEW.g:7607:1: ( ( '&' )? ) |
| { |
| // InternalSEW.g:7607:1: ( ( '&' )? ) |
| // InternalSEW.g:7608:2: ( '&' )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getAmpersandKeyword_1_5()); |
| } |
| // InternalSEW.g:7609:2: ( '&' )? |
| int alt89=2; |
| int LA89_0 = input.LA(1); |
| |
| if ( (LA89_0==67) ) { |
| alt89=1; |
| } |
| switch (alt89) { |
| case 1 : |
| // InternalSEW.g:7609:3: '&' |
| { |
| match(input,67,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getAmpersandKeyword_1_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__5__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__6" |
| // InternalSEW.g:7617:1: rule__DeprecatedObject__Group_1__6 : rule__DeprecatedObject__Group_1__6__Impl rule__DeprecatedObject__Group_1__7 ; |
| public final void rule__DeprecatedObject__Group_1__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7621:1: ( rule__DeprecatedObject__Group_1__6__Impl rule__DeprecatedObject__Group_1__7 ) |
| // InternalSEW.g:7622:2: rule__DeprecatedObject__Group_1__6__Impl rule__DeprecatedObject__Group_1__7 |
| { |
| pushFollow(FollowSets000.FOLLOW_64); |
| rule__DeprecatedObject__Group_1__6__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_1__7(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__6" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__6__Impl" |
| // InternalSEW.g:7629:1: rule__DeprecatedObject__Group_1__6__Impl : ( ( rule__DeprecatedObject__TypeAssignment_1_6 ) ) ; |
| public final void rule__DeprecatedObject__Group_1__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7633:1: ( ( ( rule__DeprecatedObject__TypeAssignment_1_6 ) ) ) |
| // InternalSEW.g:7634:1: ( ( rule__DeprecatedObject__TypeAssignment_1_6 ) ) |
| { |
| // InternalSEW.g:7634:1: ( ( rule__DeprecatedObject__TypeAssignment_1_6 ) ) |
| // InternalSEW.g:7635:2: ( rule__DeprecatedObject__TypeAssignment_1_6 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getTypeAssignment_1_6()); |
| } |
| // InternalSEW.g:7636:2: ( rule__DeprecatedObject__TypeAssignment_1_6 ) |
| // InternalSEW.g:7636:3: rule__DeprecatedObject__TypeAssignment_1_6 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__TypeAssignment_1_6(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getTypeAssignment_1_6()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__6__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__7" |
| // InternalSEW.g:7644:1: rule__DeprecatedObject__Group_1__7 : rule__DeprecatedObject__Group_1__7__Impl rule__DeprecatedObject__Group_1__8 ; |
| public final void rule__DeprecatedObject__Group_1__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7648:1: ( rule__DeprecatedObject__Group_1__7__Impl rule__DeprecatedObject__Group_1__8 ) |
| // InternalSEW.g:7649:2: rule__DeprecatedObject__Group_1__7__Impl rule__DeprecatedObject__Group_1__8 |
| { |
| pushFollow(FollowSets000.FOLLOW_65); |
| rule__DeprecatedObject__Group_1__7__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_1__8(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__7" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__7__Impl" |
| // InternalSEW.g:7656:1: rule__DeprecatedObject__Group_1__7__Impl : ( 'is' ) ; |
| public final void rule__DeprecatedObject__Group_1__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7660:1: ( ( 'is' ) ) |
| // InternalSEW.g:7661:1: ( 'is' ) |
| { |
| // InternalSEW.g:7661:1: ( 'is' ) |
| // InternalSEW.g:7662:2: 'is' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getIsKeyword_1_7()); |
| } |
| match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getIsKeyword_1_7()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__7__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__8" |
| // InternalSEW.g:7671:1: rule__DeprecatedObject__Group_1__8 : rule__DeprecatedObject__Group_1__8__Impl rule__DeprecatedObject__Group_1__9 ; |
| public final void rule__DeprecatedObject__Group_1__8() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7675:1: ( rule__DeprecatedObject__Group_1__8__Impl rule__DeprecatedObject__Group_1__9 ) |
| // InternalSEW.g:7676:2: rule__DeprecatedObject__Group_1__8__Impl rule__DeprecatedObject__Group_1__9 |
| { |
| pushFollow(FollowSets000.FOLLOW_65); |
| rule__DeprecatedObject__Group_1__8__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_1__9(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__8" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__8__Impl" |
| // InternalSEW.g:7683:1: rule__DeprecatedObject__Group_1__8__Impl : ( ( rule__DeprecatedObject__ElementAssignment_1_8 )* ) ; |
| public final void rule__DeprecatedObject__Group_1__8__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7687:1: ( ( ( rule__DeprecatedObject__ElementAssignment_1_8 )* ) ) |
| // InternalSEW.g:7688:1: ( ( rule__DeprecatedObject__ElementAssignment_1_8 )* ) |
| { |
| // InternalSEW.g:7688:1: ( ( rule__DeprecatedObject__ElementAssignment_1_8 )* ) |
| // InternalSEW.g:7689:2: ( rule__DeprecatedObject__ElementAssignment_1_8 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getElementAssignment_1_8()); |
| } |
| // InternalSEW.g:7690:2: ( rule__DeprecatedObject__ElementAssignment_1_8 )* |
| loop90: |
| do { |
| int alt90=2; |
| int LA90_0 = input.LA(1); |
| |
| if ( (LA90_0==45) ) { |
| int LA90_1 = input.LA(2); |
| |
| if ( (LA90_1==RULE_STRING||LA90_1==55||(LA90_1>=57 && LA90_1<=58)) ) { |
| alt90=1; |
| } |
| |
| |
| } |
| else if ( ((LA90_0>=RULE_XIDENDIFIER && LA90_0<=RULE_AT_IDENTIFIER)||LA90_0==14||LA90_0==18||(LA90_0>=42 && LA90_0<=44)||(LA90_0>=46 && LA90_0<=47)) ) { |
| alt90=1; |
| } |
| |
| |
| switch (alt90) { |
| case 1 : |
| // InternalSEW.g:7690:3: rule__DeprecatedObject__ElementAssignment_1_8 |
| { |
| pushFollow(FollowSets000.FOLLOW_66); |
| rule__DeprecatedObject__ElementAssignment_1_8(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop90; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getElementAssignment_1_8()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__8__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__9" |
| // InternalSEW.g:7698:1: rule__DeprecatedObject__Group_1__9 : rule__DeprecatedObject__Group_1__9__Impl ; |
| public final void rule__DeprecatedObject__Group_1__9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7702:1: ( rule__DeprecatedObject__Group_1__9__Impl ) |
| // InternalSEW.g:7703:2: rule__DeprecatedObject__Group_1__9__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedObject__Group_1__9__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__9" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__Group_1__9__Impl" |
| // InternalSEW.g:7709:1: rule__DeprecatedObject__Group_1__9__Impl : ( 'endprototype' ) ; |
| public final void rule__DeprecatedObject__Group_1__9__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7713:1: ( ( 'endprototype' ) ) |
| // InternalSEW.g:7714:1: ( 'endprototype' ) |
| { |
| // InternalSEW.g:7714:1: ( 'endprototype' ) |
| // InternalSEW.g:7715:2: 'endprototype' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getEndprototypeKeyword_1_9()); |
| } |
| match(input,45,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getEndprototypeKeyword_1_9()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__Group_1__9__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__0" |
| // InternalSEW.g:7725:1: rule__DeprecatedSection__Group_0__0 : rule__DeprecatedSection__Group_0__0__Impl rule__DeprecatedSection__Group_0__1 ; |
| public final void rule__DeprecatedSection__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7729:1: ( rule__DeprecatedSection__Group_0__0__Impl rule__DeprecatedSection__Group_0__1 ) |
| // InternalSEW.g:7730:2: rule__DeprecatedSection__Group_0__0__Impl rule__DeprecatedSection__Group_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_67); |
| rule__DeprecatedSection__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__0" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__0__Impl" |
| // InternalSEW.g:7737:1: rule__DeprecatedSection__Group_0__0__Impl : ( () ) ; |
| public final void rule__DeprecatedSection__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7741:1: ( ( () ) ) |
| // InternalSEW.g:7742:1: ( () ) |
| { |
| // InternalSEW.g:7742:1: ( () ) |
| // InternalSEW.g:7743:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getWSectionAction_0_0()); |
| } |
| // InternalSEW.g:7744:2: () |
| // InternalSEW.g:7744:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getWSectionAction_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__1" |
| // InternalSEW.g:7752:1: rule__DeprecatedSection__Group_0__1 : rule__DeprecatedSection__Group_0__1__Impl rule__DeprecatedSection__Group_0__2 ; |
| public final void rule__DeprecatedSection__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7756:1: ( rule__DeprecatedSection__Group_0__1__Impl rule__DeprecatedSection__Group_0__2 ) |
| // InternalSEW.g:7757:2: rule__DeprecatedSection__Group_0__1__Impl rule__DeprecatedSection__Group_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__DeprecatedSection__Group_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__1" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__1__Impl" |
| // InternalSEW.g:7764:1: rule__DeprecatedSection__Group_0__1__Impl : ( 'section' ) ; |
| public final void rule__DeprecatedSection__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7768:1: ( ( 'section' ) ) |
| // InternalSEW.g:7769:1: ( 'section' ) |
| { |
| // InternalSEW.g:7769:1: ( 'section' ) |
| // InternalSEW.g:7770:2: 'section' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getSectionKeyword_0_1()); |
| } |
| match(input,46,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getSectionKeyword_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__2" |
| // InternalSEW.g:7779:1: rule__DeprecatedSection__Group_0__2 : rule__DeprecatedSection__Group_0__2__Impl rule__DeprecatedSection__Group_0__3 ; |
| public final void rule__DeprecatedSection__Group_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7783:1: ( rule__DeprecatedSection__Group_0__2__Impl rule__DeprecatedSection__Group_0__3 ) |
| // InternalSEW.g:7784:2: rule__DeprecatedSection__Group_0__2__Impl rule__DeprecatedSection__Group_0__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_68); |
| rule__DeprecatedSection__Group_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_0__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__2" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__2__Impl" |
| // InternalSEW.g:7791:1: rule__DeprecatedSection__Group_0__2__Impl : ( ( rule__DeprecatedSection__NameAssignment_0_2 ) ) ; |
| public final void rule__DeprecatedSection__Group_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7795:1: ( ( ( rule__DeprecatedSection__NameAssignment_0_2 ) ) ) |
| // InternalSEW.g:7796:1: ( ( rule__DeprecatedSection__NameAssignment_0_2 ) ) |
| { |
| // InternalSEW.g:7796:1: ( ( rule__DeprecatedSection__NameAssignment_0_2 ) ) |
| // InternalSEW.g:7797:2: ( rule__DeprecatedSection__NameAssignment_0_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getNameAssignment_0_2()); |
| } |
| // InternalSEW.g:7798:2: ( rule__DeprecatedSection__NameAssignment_0_2 ) |
| // InternalSEW.g:7798:3: rule__DeprecatedSection__NameAssignment_0_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__NameAssignment_0_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getNameAssignment_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__3" |
| // InternalSEW.g:7806:1: rule__DeprecatedSection__Group_0__3 : rule__DeprecatedSection__Group_0__3__Impl rule__DeprecatedSection__Group_0__4 ; |
| public final void rule__DeprecatedSection__Group_0__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7810:1: ( rule__DeprecatedSection__Group_0__3__Impl rule__DeprecatedSection__Group_0__4 ) |
| // InternalSEW.g:7811:2: rule__DeprecatedSection__Group_0__3__Impl rule__DeprecatedSection__Group_0__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_68); |
| rule__DeprecatedSection__Group_0__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_0__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__3" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__3__Impl" |
| // InternalSEW.g:7818:1: rule__DeprecatedSection__Group_0__3__Impl : ( ( rule__DeprecatedSection__ElementAssignment_0_3 )* ) ; |
| public final void rule__DeprecatedSection__Group_0__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7822:1: ( ( ( rule__DeprecatedSection__ElementAssignment_0_3 )* ) ) |
| // InternalSEW.g:7823:1: ( ( rule__DeprecatedSection__ElementAssignment_0_3 )* ) |
| { |
| // InternalSEW.g:7823:1: ( ( rule__DeprecatedSection__ElementAssignment_0_3 )* ) |
| // InternalSEW.g:7824:2: ( rule__DeprecatedSection__ElementAssignment_0_3 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementAssignment_0_3()); |
| } |
| // InternalSEW.g:7825:2: ( rule__DeprecatedSection__ElementAssignment_0_3 )* |
| loop91: |
| do { |
| int alt91=2; |
| alt91 = dfa91.predict(input); |
| switch (alt91) { |
| case 1 : |
| // InternalSEW.g:7825:3: rule__DeprecatedSection__ElementAssignment_0_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_69); |
| rule__DeprecatedSection__ElementAssignment_0_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop91; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementAssignment_0_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__3__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__4" |
| // InternalSEW.g:7833:1: rule__DeprecatedSection__Group_0__4 : rule__DeprecatedSection__Group_0__4__Impl rule__DeprecatedSection__Group_0__5 ; |
| public final void rule__DeprecatedSection__Group_0__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7837:1: ( rule__DeprecatedSection__Group_0__4__Impl rule__DeprecatedSection__Group_0__5 ) |
| // InternalSEW.g:7838:2: rule__DeprecatedSection__Group_0__4__Impl rule__DeprecatedSection__Group_0__5 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__DeprecatedSection__Group_0__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_0__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__4" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__4__Impl" |
| // InternalSEW.g:7845:1: rule__DeprecatedSection__Group_0__4__Impl : ( 'endsection' ) ; |
| public final void rule__DeprecatedSection__Group_0__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7849:1: ( ( 'endsection' ) ) |
| // InternalSEW.g:7850:1: ( 'endsection' ) |
| { |
| // InternalSEW.g:7850:1: ( 'endsection' ) |
| // InternalSEW.g:7851:2: 'endsection' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getEndsectionKeyword_0_4()); |
| } |
| match(input,47,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getEndsectionKeyword_0_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__4__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__5" |
| // InternalSEW.g:7860:1: rule__DeprecatedSection__Group_0__5 : rule__DeprecatedSection__Group_0__5__Impl ; |
| public final void rule__DeprecatedSection__Group_0__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7864:1: ( rule__DeprecatedSection__Group_0__5__Impl ) |
| // InternalSEW.g:7865:2: rule__DeprecatedSection__Group_0__5__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_0__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__5" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_0__5__Impl" |
| // InternalSEW.g:7871:1: rule__DeprecatedSection__Group_0__5__Impl : ( ( ruleXID )? ) ; |
| public final void rule__DeprecatedSection__Group_0__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7875:1: ( ( ( ruleXID )? ) ) |
| // InternalSEW.g:7876:1: ( ( ruleXID )? ) |
| { |
| // InternalSEW.g:7876:1: ( ( ruleXID )? ) |
| // InternalSEW.g:7877:2: ( ruleXID )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getXIDParserRuleCall_0_5()); |
| } |
| // InternalSEW.g:7878:2: ( ruleXID )? |
| int alt92=2; |
| alt92 = dfa92.predict(input); |
| switch (alt92) { |
| case 1 : |
| // InternalSEW.g:7878:3: ruleXID |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleXID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getXIDParserRuleCall_0_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_0__5__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1__0" |
| // InternalSEW.g:7887:1: rule__DeprecatedSection__Group_1__0 : rule__DeprecatedSection__Group_1__0__Impl rule__DeprecatedSection__Group_1__1 ; |
| public final void rule__DeprecatedSection__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7891:1: ( rule__DeprecatedSection__Group_1__0__Impl rule__DeprecatedSection__Group_1__1 ) |
| // InternalSEW.g:7892:2: rule__DeprecatedSection__Group_1__0__Impl rule__DeprecatedSection__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_17); |
| rule__DeprecatedSection__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1__0" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1__0__Impl" |
| // InternalSEW.g:7899:1: rule__DeprecatedSection__Group_1__0__Impl : ( ( rule__DeprecatedSection__NameAssignment_1_0 ) ) ; |
| public final void rule__DeprecatedSection__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7903:1: ( ( ( rule__DeprecatedSection__NameAssignment_1_0 ) ) ) |
| // InternalSEW.g:7904:1: ( ( rule__DeprecatedSection__NameAssignment_1_0 ) ) |
| { |
| // InternalSEW.g:7904:1: ( ( rule__DeprecatedSection__NameAssignment_1_0 ) ) |
| // InternalSEW.g:7905:2: ( rule__DeprecatedSection__NameAssignment_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getNameAssignment_1_0()); |
| } |
| // InternalSEW.g:7906:2: ( rule__DeprecatedSection__NameAssignment_1_0 ) |
| // InternalSEW.g:7906:3: rule__DeprecatedSection__NameAssignment_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__NameAssignment_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getNameAssignment_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1__1" |
| // InternalSEW.g:7914:1: rule__DeprecatedSection__Group_1__1 : rule__DeprecatedSection__Group_1__1__Impl rule__DeprecatedSection__Group_1__2 ; |
| public final void rule__DeprecatedSection__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7918:1: ( rule__DeprecatedSection__Group_1__1__Impl rule__DeprecatedSection__Group_1__2 ) |
| // InternalSEW.g:7919:2: rule__DeprecatedSection__Group_1__1__Impl rule__DeprecatedSection__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_17); |
| rule__DeprecatedSection__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1__1" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1__1__Impl" |
| // InternalSEW.g:7926:1: rule__DeprecatedSection__Group_1__1__Impl : ( ( rule__DeprecatedSection__DescriptionAssignment_1_1 )? ) ; |
| public final void rule__DeprecatedSection__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7930:1: ( ( ( rule__DeprecatedSection__DescriptionAssignment_1_1 )? ) ) |
| // InternalSEW.g:7931:1: ( ( rule__DeprecatedSection__DescriptionAssignment_1_1 )? ) |
| { |
| // InternalSEW.g:7931:1: ( ( rule__DeprecatedSection__DescriptionAssignment_1_1 )? ) |
| // InternalSEW.g:7932:2: ( rule__DeprecatedSection__DescriptionAssignment_1_1 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getDescriptionAssignment_1_1()); |
| } |
| // InternalSEW.g:7933:2: ( rule__DeprecatedSection__DescriptionAssignment_1_1 )? |
| int alt93=2; |
| int LA93_0 = input.LA(1); |
| |
| if ( (LA93_0==RULE_STRING) ) { |
| alt93=1; |
| } |
| switch (alt93) { |
| case 1 : |
| // InternalSEW.g:7933:3: rule__DeprecatedSection__DescriptionAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__DescriptionAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getDescriptionAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1__2" |
| // InternalSEW.g:7941:1: rule__DeprecatedSection__Group_1__2 : rule__DeprecatedSection__Group_1__2__Impl ; |
| public final void rule__DeprecatedSection__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7945:1: ( rule__DeprecatedSection__Group_1__2__Impl ) |
| // InternalSEW.g:7946:2: rule__DeprecatedSection__Group_1__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1__2" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1__2__Impl" |
| // InternalSEW.g:7952:1: rule__DeprecatedSection__Group_1__2__Impl : ( ( rule__DeprecatedSection__Alternatives_1_2 ) ) ; |
| public final void rule__DeprecatedSection__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7956:1: ( ( ( rule__DeprecatedSection__Alternatives_1_2 ) ) ) |
| // InternalSEW.g:7957:1: ( ( rule__DeprecatedSection__Alternatives_1_2 ) ) |
| { |
| // InternalSEW.g:7957:1: ( ( rule__DeprecatedSection__Alternatives_1_2 ) ) |
| // InternalSEW.g:7958:2: ( rule__DeprecatedSection__Alternatives_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getAlternatives_1_2()); |
| } |
| // InternalSEW.g:7959:2: ( rule__DeprecatedSection__Alternatives_1_2 ) |
| // InternalSEW.g:7959:3: rule__DeprecatedSection__Alternatives_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Alternatives_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getAlternatives_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1_2_0__0" |
| // InternalSEW.g:7968:1: rule__DeprecatedSection__Group_1_2_0__0 : rule__DeprecatedSection__Group_1_2_0__0__Impl rule__DeprecatedSection__Group_1_2_0__1 ; |
| public final void rule__DeprecatedSection__Group_1_2_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7972:1: ( rule__DeprecatedSection__Group_1_2_0__0__Impl rule__DeprecatedSection__Group_1_2_0__1 ) |
| // InternalSEW.g:7973:2: rule__DeprecatedSection__Group_1_2_0__0__Impl rule__DeprecatedSection__Group_1_2_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_70); |
| rule__DeprecatedSection__Group_1_2_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_1_2_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1_2_0__0" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1_2_0__0__Impl" |
| // InternalSEW.g:7980:1: rule__DeprecatedSection__Group_1_2_0__0__Impl : ( '[' ) ; |
| public final void rule__DeprecatedSection__Group_1_2_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7984:1: ( ( '[' ) ) |
| // InternalSEW.g:7985:1: ( '[' ) |
| { |
| // InternalSEW.g:7985:1: ( '[' ) |
| // InternalSEW.g:7986:2: '[' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getLeftSquareBracketKeyword_1_2_0_0()); |
| } |
| match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getLeftSquareBracketKeyword_1_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1_2_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1_2_0__1" |
| // InternalSEW.g:7995:1: rule__DeprecatedSection__Group_1_2_0__1 : rule__DeprecatedSection__Group_1_2_0__1__Impl rule__DeprecatedSection__Group_1_2_0__2 ; |
| public final void rule__DeprecatedSection__Group_1_2_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:7999:1: ( rule__DeprecatedSection__Group_1_2_0__1__Impl rule__DeprecatedSection__Group_1_2_0__2 ) |
| // InternalSEW.g:8000:2: rule__DeprecatedSection__Group_1_2_0__1__Impl rule__DeprecatedSection__Group_1_2_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_70); |
| rule__DeprecatedSection__Group_1_2_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_1_2_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1_2_0__1" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1_2_0__1__Impl" |
| // InternalSEW.g:8007:1: rule__DeprecatedSection__Group_1_2_0__1__Impl : ( ( rule__DeprecatedSection__ElementAssignment_1_2_0_1 )* ) ; |
| public final void rule__DeprecatedSection__Group_1_2_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8011:1: ( ( ( rule__DeprecatedSection__ElementAssignment_1_2_0_1 )* ) ) |
| // InternalSEW.g:8012:1: ( ( rule__DeprecatedSection__ElementAssignment_1_2_0_1 )* ) |
| { |
| // InternalSEW.g:8012:1: ( ( rule__DeprecatedSection__ElementAssignment_1_2_0_1 )* ) |
| // InternalSEW.g:8013:2: ( rule__DeprecatedSection__ElementAssignment_1_2_0_1 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementAssignment_1_2_0_1()); |
| } |
| // InternalSEW.g:8014:2: ( rule__DeprecatedSection__ElementAssignment_1_2_0_1 )* |
| loop94: |
| do { |
| int alt94=2; |
| int LA94_0 = input.LA(1); |
| |
| if ( ((LA94_0>=RULE_XIDENDIFIER && LA94_0<=RULE_AT_IDENTIFIER)||LA94_0==14||LA94_0==18||(LA94_0>=42 && LA94_0<=47)) ) { |
| alt94=1; |
| } |
| |
| |
| switch (alt94) { |
| case 1 : |
| // InternalSEW.g:8014:3: rule__DeprecatedSection__ElementAssignment_1_2_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_69); |
| rule__DeprecatedSection__ElementAssignment_1_2_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop94; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementAssignment_1_2_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1_2_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1_2_0__2" |
| // InternalSEW.g:8022:1: rule__DeprecatedSection__Group_1_2_0__2 : rule__DeprecatedSection__Group_1_2_0__2__Impl ; |
| public final void rule__DeprecatedSection__Group_1_2_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8026:1: ( rule__DeprecatedSection__Group_1_2_0__2__Impl ) |
| // InternalSEW.g:8027:2: rule__DeprecatedSection__Group_1_2_0__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_1_2_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1_2_0__2" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1_2_0__2__Impl" |
| // InternalSEW.g:8033:1: rule__DeprecatedSection__Group_1_2_0__2__Impl : ( ']' ) ; |
| public final void rule__DeprecatedSection__Group_1_2_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8037:1: ( ( ']' ) ) |
| // InternalSEW.g:8038:1: ( ']' ) |
| { |
| // InternalSEW.g:8038:1: ( ']' ) |
| // InternalSEW.g:8039:2: ']' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getRightSquareBracketKeyword_1_2_0_2()); |
| } |
| match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getRightSquareBracketKeyword_1_2_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1_2_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1_2_1__0" |
| // InternalSEW.g:8049:1: rule__DeprecatedSection__Group_1_2_1__0 : rule__DeprecatedSection__Group_1_2_1__0__Impl rule__DeprecatedSection__Group_1_2_1__1 ; |
| public final void rule__DeprecatedSection__Group_1_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8053:1: ( rule__DeprecatedSection__Group_1_2_1__0__Impl rule__DeprecatedSection__Group_1_2_1__1 ) |
| // InternalSEW.g:8054:2: rule__DeprecatedSection__Group_1_2_1__0__Impl rule__DeprecatedSection__Group_1_2_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_68); |
| rule__DeprecatedSection__Group_1_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_1_2_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1_2_1__0" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1_2_1__0__Impl" |
| // InternalSEW.g:8061:1: rule__DeprecatedSection__Group_1_2_1__0__Impl : ( ':' ) ; |
| public final void rule__DeprecatedSection__Group_1_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8065:1: ( ( ':' ) ) |
| // InternalSEW.g:8066:1: ( ':' ) |
| { |
| // InternalSEW.g:8066:1: ( ':' ) |
| // InternalSEW.g:8067:2: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getColonKeyword_1_2_1_0()); |
| } |
| match(input,57,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getColonKeyword_1_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1_2_1__1" |
| // InternalSEW.g:8076:1: rule__DeprecatedSection__Group_1_2_1__1 : rule__DeprecatedSection__Group_1_2_1__1__Impl ; |
| public final void rule__DeprecatedSection__Group_1_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8080:1: ( rule__DeprecatedSection__Group_1_2_1__1__Impl ) |
| // InternalSEW.g:8081:2: rule__DeprecatedSection__Group_1_2_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__Group_1_2_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1_2_1__1" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__Group_1_2_1__1__Impl" |
| // InternalSEW.g:8087:1: rule__DeprecatedSection__Group_1_2_1__1__Impl : ( ( rule__DeprecatedSection__ElementAssignment_1_2_1_1 )* ) ; |
| public final void rule__DeprecatedSection__Group_1_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8091:1: ( ( ( rule__DeprecatedSection__ElementAssignment_1_2_1_1 )* ) ) |
| // InternalSEW.g:8092:1: ( ( rule__DeprecatedSection__ElementAssignment_1_2_1_1 )* ) |
| { |
| // InternalSEW.g:8092:1: ( ( rule__DeprecatedSection__ElementAssignment_1_2_1_1 )* ) |
| // InternalSEW.g:8093:2: ( rule__DeprecatedSection__ElementAssignment_1_2_1_1 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementAssignment_1_2_1_1()); |
| } |
| // InternalSEW.g:8094:2: ( rule__DeprecatedSection__ElementAssignment_1_2_1_1 )* |
| loop95: |
| do { |
| int alt95=2; |
| alt95 = dfa95.predict(input); |
| switch (alt95) { |
| case 1 : |
| // InternalSEW.g:8094:3: rule__DeprecatedSection__ElementAssignment_1_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_69); |
| rule__DeprecatedSection__ElementAssignment_1_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop95; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementAssignment_1_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__Group_1_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__Group__0" |
| // InternalSEW.g:8103:1: rule__DeprecatedAttribute__Group__0 : rule__DeprecatedAttribute__Group__0__Impl rule__DeprecatedAttribute__Group__1 ; |
| public final void rule__DeprecatedAttribute__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8107:1: ( rule__DeprecatedAttribute__Group__0__Impl rule__DeprecatedAttribute__Group__1 ) |
| // InternalSEW.g:8108:2: rule__DeprecatedAttribute__Group__0__Impl rule__DeprecatedAttribute__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_65); |
| rule__DeprecatedAttribute__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedAttribute__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__Group__0" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__Group__0__Impl" |
| // InternalSEW.g:8115:1: rule__DeprecatedAttribute__Group__0__Impl : ( () ) ; |
| public final void rule__DeprecatedAttribute__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8119:1: ( ( () ) ) |
| // InternalSEW.g:8120:1: ( () ) |
| { |
| // InternalSEW.g:8120:1: ( () ) |
| // InternalSEW.g:8121:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeAccess().getWAttributeAction_0()); |
| } |
| // InternalSEW.g:8122:2: () |
| // InternalSEW.g:8122:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeAccess().getWAttributeAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__Group__1" |
| // InternalSEW.g:8130:1: rule__DeprecatedAttribute__Group__1 : rule__DeprecatedAttribute__Group__1__Impl rule__DeprecatedAttribute__Group__2 ; |
| public final void rule__DeprecatedAttribute__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8134:1: ( rule__DeprecatedAttribute__Group__1__Impl rule__DeprecatedAttribute__Group__2 ) |
| // InternalSEW.g:8135:2: rule__DeprecatedAttribute__Group__1__Impl rule__DeprecatedAttribute__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_19); |
| rule__DeprecatedAttribute__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedAttribute__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__Group__1" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__Group__1__Impl" |
| // InternalSEW.g:8142:1: rule__DeprecatedAttribute__Group__1__Impl : ( ( rule__DeprecatedAttribute__NameAssignment_1 ) ) ; |
| public final void rule__DeprecatedAttribute__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8146:1: ( ( ( rule__DeprecatedAttribute__NameAssignment_1 ) ) ) |
| // InternalSEW.g:8147:1: ( ( rule__DeprecatedAttribute__NameAssignment_1 ) ) |
| { |
| // InternalSEW.g:8147:1: ( ( rule__DeprecatedAttribute__NameAssignment_1 ) ) |
| // InternalSEW.g:8148:2: ( rule__DeprecatedAttribute__NameAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeAccess().getNameAssignment_1()); |
| } |
| // InternalSEW.g:8149:2: ( rule__DeprecatedAttribute__NameAssignment_1 ) |
| // InternalSEW.g:8149:3: rule__DeprecatedAttribute__NameAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedAttribute__NameAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeAccess().getNameAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__Group__2" |
| // InternalSEW.g:8157:1: rule__DeprecatedAttribute__Group__2 : rule__DeprecatedAttribute__Group__2__Impl rule__DeprecatedAttribute__Group__3 ; |
| public final void rule__DeprecatedAttribute__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8161:1: ( rule__DeprecatedAttribute__Group__2__Impl rule__DeprecatedAttribute__Group__3 ) |
| // InternalSEW.g:8162:2: rule__DeprecatedAttribute__Group__2__Impl rule__DeprecatedAttribute__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__DeprecatedAttribute__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedAttribute__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__Group__2" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__Group__2__Impl" |
| // InternalSEW.g:8169:1: rule__DeprecatedAttribute__Group__2__Impl : ( '=' ) ; |
| public final void rule__DeprecatedAttribute__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8173:1: ( ( '=' ) ) |
| // InternalSEW.g:8174:1: ( '=' ) |
| { |
| // InternalSEW.g:8174:1: ( '=' ) |
| // InternalSEW.g:8175:2: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeAccess().getEqualsSignKeyword_2()); |
| } |
| match(input,58,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeAccess().getEqualsSignKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__Group__3" |
| // InternalSEW.g:8184:1: rule__DeprecatedAttribute__Group__3 : rule__DeprecatedAttribute__Group__3__Impl rule__DeprecatedAttribute__Group__4 ; |
| public final void rule__DeprecatedAttribute__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8188:1: ( rule__DeprecatedAttribute__Group__3__Impl rule__DeprecatedAttribute__Group__4 ) |
| // InternalSEW.g:8189:2: rule__DeprecatedAttribute__Group__3__Impl rule__DeprecatedAttribute__Group__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_21); |
| rule__DeprecatedAttribute__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedAttribute__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__Group__3" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__Group__3__Impl" |
| // InternalSEW.g:8196:1: rule__DeprecatedAttribute__Group__3__Impl : ( ( rule__DeprecatedAttribute__ValueAssignment_3 ) ) ; |
| public final void rule__DeprecatedAttribute__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8200:1: ( ( ( rule__DeprecatedAttribute__ValueAssignment_3 ) ) ) |
| // InternalSEW.g:8201:1: ( ( rule__DeprecatedAttribute__ValueAssignment_3 ) ) |
| { |
| // InternalSEW.g:8201:1: ( ( rule__DeprecatedAttribute__ValueAssignment_3 ) ) |
| // InternalSEW.g:8202:2: ( rule__DeprecatedAttribute__ValueAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeAccess().getValueAssignment_3()); |
| } |
| // InternalSEW.g:8203:2: ( rule__DeprecatedAttribute__ValueAssignment_3 ) |
| // InternalSEW.g:8203:3: rule__DeprecatedAttribute__ValueAssignment_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedAttribute__ValueAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeAccess().getValueAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__Group__4" |
| // InternalSEW.g:8211:1: rule__DeprecatedAttribute__Group__4 : rule__DeprecatedAttribute__Group__4__Impl ; |
| public final void rule__DeprecatedAttribute__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8215:1: ( rule__DeprecatedAttribute__Group__4__Impl ) |
| // InternalSEW.g:8216:2: rule__DeprecatedAttribute__Group__4__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedAttribute__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__Group__4" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__Group__4__Impl" |
| // InternalSEW.g:8222:1: rule__DeprecatedAttribute__Group__4__Impl : ( ( ';' )? ) ; |
| public final void rule__DeprecatedAttribute__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8226:1: ( ( ( ';' )? ) ) |
| // InternalSEW.g:8227:1: ( ( ';' )? ) |
| { |
| // InternalSEW.g:8227:1: ( ( ';' )? ) |
| // InternalSEW.g:8228:2: ( ';' )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeAccess().getSemicolonKeyword_4()); |
| } |
| // InternalSEW.g:8229:2: ( ';' )? |
| int alt96=2; |
| int LA96_0 = input.LA(1); |
| |
| if ( (LA96_0==59) ) { |
| alt96=1; |
| } |
| switch (alt96) { |
| case 1 : |
| // InternalSEW.g:8229:3: ';' |
| { |
| match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeAccess().getSemicolonKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__Group__0" |
| // InternalSEW.g:8238:1: rule__DeprecatedExpression__Group__0 : rule__DeprecatedExpression__Group__0__Impl rule__DeprecatedExpression__Group__1 ; |
| public final void rule__DeprecatedExpression__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8242:1: ( rule__DeprecatedExpression__Group__0__Impl rule__DeprecatedExpression__Group__1 ) |
| // InternalSEW.g:8243:2: rule__DeprecatedExpression__Group__0__Impl rule__DeprecatedExpression__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__DeprecatedExpression__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedExpression__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__Group__0" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__Group__0__Impl" |
| // InternalSEW.g:8250:1: rule__DeprecatedExpression__Group__0__Impl : ( () ) ; |
| public final void rule__DeprecatedExpression__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8254:1: ( ( () ) ) |
| // InternalSEW.g:8255:1: ( () ) |
| { |
| // InternalSEW.g:8255:1: ( () ) |
| // InternalSEW.g:8256:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedExpressionAccess().getExpressionAction_0()); |
| } |
| // InternalSEW.g:8257:2: () |
| // InternalSEW.g:8257:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedExpressionAccess().getExpressionAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__Group__1" |
| // InternalSEW.g:8265:1: rule__DeprecatedExpression__Group__1 : rule__DeprecatedExpression__Group__1__Impl rule__DeprecatedExpression__Group__2 ; |
| public final void rule__DeprecatedExpression__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8269:1: ( rule__DeprecatedExpression__Group__1__Impl rule__DeprecatedExpression__Group__2 ) |
| // InternalSEW.g:8270:2: rule__DeprecatedExpression__Group__1__Impl rule__DeprecatedExpression__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_71); |
| rule__DeprecatedExpression__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedExpression__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__Group__1" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__Group__1__Impl" |
| // InternalSEW.g:8277:1: rule__DeprecatedExpression__Group__1__Impl : ( '${' ) ; |
| public final void rule__DeprecatedExpression__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8281:1: ( ( '${' ) ) |
| // InternalSEW.g:8282:1: ( '${' ) |
| { |
| // InternalSEW.g:8282:1: ( '${' ) |
| // InternalSEW.g:8283:2: '${' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedExpressionAccess().getDollarSignLeftCurlyBracketKeyword_1()); |
| } |
| match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedExpressionAccess().getDollarSignLeftCurlyBracketKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__Group__2" |
| // InternalSEW.g:8292:1: rule__DeprecatedExpression__Group__2 : rule__DeprecatedExpression__Group__2__Impl rule__DeprecatedExpression__Group__3 ; |
| public final void rule__DeprecatedExpression__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8296:1: ( rule__DeprecatedExpression__Group__2__Impl rule__DeprecatedExpression__Group__3 ) |
| // InternalSEW.g:8297:2: rule__DeprecatedExpression__Group__2__Impl rule__DeprecatedExpression__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_72); |
| rule__DeprecatedExpression__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedExpression__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__Group__2" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__Group__2__Impl" |
| // InternalSEW.g:8304:1: rule__DeprecatedExpression__Group__2__Impl : ( ( rule__DeprecatedExpression__OperatorAssignment_2 ) ) ; |
| public final void rule__DeprecatedExpression__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8308:1: ( ( ( rule__DeprecatedExpression__OperatorAssignment_2 ) ) ) |
| // InternalSEW.g:8309:1: ( ( rule__DeprecatedExpression__OperatorAssignment_2 ) ) |
| { |
| // InternalSEW.g:8309:1: ( ( rule__DeprecatedExpression__OperatorAssignment_2 ) ) |
| // InternalSEW.g:8310:2: ( rule__DeprecatedExpression__OperatorAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedExpressionAccess().getOperatorAssignment_2()); |
| } |
| // InternalSEW.g:8311:2: ( rule__DeprecatedExpression__OperatorAssignment_2 ) |
| // InternalSEW.g:8311:3: rule__DeprecatedExpression__OperatorAssignment_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedExpression__OperatorAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedExpressionAccess().getOperatorAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__Group__3" |
| // InternalSEW.g:8319:1: rule__DeprecatedExpression__Group__3 : rule__DeprecatedExpression__Group__3__Impl rule__DeprecatedExpression__Group__4 ; |
| public final void rule__DeprecatedExpression__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8323:1: ( rule__DeprecatedExpression__Group__3__Impl rule__DeprecatedExpression__Group__4 ) |
| // InternalSEW.g:8324:2: rule__DeprecatedExpression__Group__3__Impl rule__DeprecatedExpression__Group__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_72); |
| rule__DeprecatedExpression__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedExpression__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__Group__3" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__Group__3__Impl" |
| // InternalSEW.g:8331:1: rule__DeprecatedExpression__Group__3__Impl : ( ( rule__DeprecatedExpression__OperandAssignment_3 )* ) ; |
| public final void rule__DeprecatedExpression__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8335:1: ( ( ( rule__DeprecatedExpression__OperandAssignment_3 )* ) ) |
| // InternalSEW.g:8336:1: ( ( rule__DeprecatedExpression__OperandAssignment_3 )* ) |
| { |
| // InternalSEW.g:8336:1: ( ( rule__DeprecatedExpression__OperandAssignment_3 )* ) |
| // InternalSEW.g:8337:2: ( rule__DeprecatedExpression__OperandAssignment_3 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedExpressionAccess().getOperandAssignment_3()); |
| } |
| // InternalSEW.g:8338:2: ( rule__DeprecatedExpression__OperandAssignment_3 )* |
| loop97: |
| do { |
| int alt97=2; |
| int LA97_0 = input.LA(1); |
| |
| if ( ((LA97_0>=RULE_CHARACTER && LA97_0<=RULE_XIDENDIFIER)||LA97_0==RULE_INT||LA97_0==14||LA97_0==18||LA97_0==20||(LA97_0>=36 && LA97_0<=47)||LA97_0==55||LA97_0==60||LA97_0==65||(LA97_0>=67 && LA97_0<=69)||LA97_0==72||(LA97_0>=74 && LA97_0<=80)) ) { |
| alt97=1; |
| } |
| |
| |
| switch (alt97) { |
| case 1 : |
| // InternalSEW.g:8338:3: rule__DeprecatedExpression__OperandAssignment_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_73); |
| rule__DeprecatedExpression__OperandAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop97; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedExpressionAccess().getOperandAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__Group__4" |
| // InternalSEW.g:8346:1: rule__DeprecatedExpression__Group__4 : rule__DeprecatedExpression__Group__4__Impl ; |
| public final void rule__DeprecatedExpression__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8350:1: ( rule__DeprecatedExpression__Group__4__Impl ) |
| // InternalSEW.g:8351:2: rule__DeprecatedExpression__Group__4__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedExpression__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__Group__4" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__Group__4__Impl" |
| // InternalSEW.g:8357:1: rule__DeprecatedExpression__Group__4__Impl : ( '}' ) ; |
| public final void rule__DeprecatedExpression__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8361:1: ( ( '}' ) ) |
| // InternalSEW.g:8362:1: ( '}' ) |
| { |
| // InternalSEW.g:8362:1: ( '}' ) |
| // InternalSEW.g:8363:2: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedExpressionAccess().getRightCurlyBracketKeyword_4()); |
| } |
| match(input,51,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedExpressionAccess().getRightCurlyBracketKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__Workflow__TypeAssignment_2_0_0" |
| // InternalSEW.g:8373:1: rule__Workflow__TypeAssignment_2_0_0 : ( ( rule__Workflow__TypeAlternatives_2_0_0_0 ) ) ; |
| public final void rule__Workflow__TypeAssignment_2_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8377:1: ( ( ( rule__Workflow__TypeAlternatives_2_0_0_0 ) ) ) |
| // InternalSEW.g:8378:2: ( ( rule__Workflow__TypeAlternatives_2_0_0_0 ) ) |
| { |
| // InternalSEW.g:8378:2: ( ( rule__Workflow__TypeAlternatives_2_0_0_0 ) ) |
| // InternalSEW.g:8379:3: ( rule__Workflow__TypeAlternatives_2_0_0_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getTypeAlternatives_2_0_0_0()); |
| } |
| // InternalSEW.g:8380:3: ( rule__Workflow__TypeAlternatives_2_0_0_0 ) |
| // InternalSEW.g:8380:4: rule__Workflow__TypeAlternatives_2_0_0_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__TypeAlternatives_2_0_0_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getTypeAlternatives_2_0_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__TypeAssignment_2_0_0" |
| |
| |
| // $ANTLR start "rule__Workflow__NameAssignment_2_0_1" |
| // InternalSEW.g:8388:1: rule__Workflow__NameAssignment_2_0_1 : ( ruleUFI ) ; |
| public final void rule__Workflow__NameAssignment_2_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8392:1: ( ( ruleUFI ) ) |
| // InternalSEW.g:8393:2: ( ruleUFI ) |
| { |
| // InternalSEW.g:8393:2: ( ruleUFI ) |
| // InternalSEW.g:8394:3: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getNameUFIParserRuleCall_2_0_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getNameUFIParserRuleCall_2_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__NameAssignment_2_0_1" |
| |
| |
| // $ANTLR start "rule__Workflow__DescriptionAssignment_2_0_2" |
| // InternalSEW.g:8403:1: rule__Workflow__DescriptionAssignment_2_0_2 : ( ruleEString ) ; |
| public final void rule__Workflow__DescriptionAssignment_2_0_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8407:1: ( ( ruleEString ) ) |
| // InternalSEW.g:8408:2: ( ruleEString ) |
| { |
| // InternalSEW.g:8408:2: ( ruleEString ) |
| // InternalSEW.g:8409:3: ruleEString |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getDescriptionEStringParserRuleCall_2_0_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEString(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getDescriptionEStringParserRuleCall_2_0_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__DescriptionAssignment_2_0_2" |
| |
| |
| // $ANTLR start "rule__Workflow__ElementAssignment_2_0_4" |
| // InternalSEW.g:8418:1: rule__Workflow__ElementAssignment_2_0_4 : ( ( rule__Workflow__ElementAlternatives_2_0_4_0 ) ) ; |
| public final void rule__Workflow__ElementAssignment_2_0_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8422:1: ( ( ( rule__Workflow__ElementAlternatives_2_0_4_0 ) ) ) |
| // InternalSEW.g:8423:2: ( ( rule__Workflow__ElementAlternatives_2_0_4_0 ) ) |
| { |
| // InternalSEW.g:8423:2: ( ( rule__Workflow__ElementAlternatives_2_0_4_0 ) ) |
| // InternalSEW.g:8424:3: ( rule__Workflow__ElementAlternatives_2_0_4_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getElementAlternatives_2_0_4_0()); |
| } |
| // InternalSEW.g:8425:3: ( rule__Workflow__ElementAlternatives_2_0_4_0 ) |
| // InternalSEW.g:8425:4: rule__Workflow__ElementAlternatives_2_0_4_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__ElementAlternatives_2_0_4_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getElementAlternatives_2_0_4_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__ElementAssignment_2_0_4" |
| |
| |
| // $ANTLR start "rule__Workflow__ElementAssignment_2_1" |
| // InternalSEW.g:8433:1: rule__Workflow__ElementAssignment_2_1 : ( ( rule__Workflow__ElementAlternatives_2_1_0 ) ) ; |
| public final void rule__Workflow__ElementAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8437:1: ( ( ( rule__Workflow__ElementAlternatives_2_1_0 ) ) ) |
| // InternalSEW.g:8438:2: ( ( rule__Workflow__ElementAlternatives_2_1_0 ) ) |
| { |
| // InternalSEW.g:8438:2: ( ( rule__Workflow__ElementAlternatives_2_1_0 ) ) |
| // InternalSEW.g:8439:3: ( rule__Workflow__ElementAlternatives_2_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getElementAlternatives_2_1_0()); |
| } |
| // InternalSEW.g:8440:3: ( rule__Workflow__ElementAlternatives_2_1_0 ) |
| // InternalSEW.g:8440:4: rule__Workflow__ElementAlternatives_2_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__ElementAlternatives_2_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getElementAlternatives_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__ElementAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__Workflow__ElementAssignment_2_2" |
| // InternalSEW.g:8448:1: rule__Workflow__ElementAssignment_2_2 : ( ruleDeprecatedObject ) ; |
| public final void rule__Workflow__ElementAssignment_2_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8452:1: ( ( ruleDeprecatedObject ) ) |
| // InternalSEW.g:8453:2: ( ruleDeprecatedObject ) |
| { |
| // InternalSEW.g:8453:2: ( ruleDeprecatedObject ) |
| // InternalSEW.g:8454:3: ruleDeprecatedObject |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getElementDeprecatedObjectParserRuleCall_2_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedObject(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWorkflowAccess().getElementDeprecatedObjectParserRuleCall_2_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Workflow__ElementAssignment_2_2" |
| |
| |
| // $ANTLR start "rule__Object__TypeAssignment_0_1" |
| // InternalSEW.g:8463:1: rule__Object__TypeAssignment_0_1 : ( ruleUFI ) ; |
| public final void rule__Object__TypeAssignment_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8467:1: ( ( ruleUFI ) ) |
| // InternalSEW.g:8468:2: ( ruleUFI ) |
| { |
| // InternalSEW.g:8468:2: ( ruleUFI ) |
| // InternalSEW.g:8469:3: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getTypeUFIParserRuleCall_0_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getTypeUFIParserRuleCall_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__TypeAssignment_0_1" |
| |
| |
| // $ANTLR start "rule__Object__NameAssignment_0_2" |
| // InternalSEW.g:8478:1: rule__Object__NameAssignment_0_2 : ( ruleUFI ) ; |
| public final void rule__Object__NameAssignment_0_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8482:1: ( ( ruleUFI ) ) |
| // InternalSEW.g:8483:2: ( ruleUFI ) |
| { |
| // InternalSEW.g:8483:2: ( ruleUFI ) |
| // InternalSEW.g:8484:3: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getNameUFIParserRuleCall_0_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getNameUFIParserRuleCall_0_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__NameAssignment_0_2" |
| |
| |
| // $ANTLR start "rule__Object__DescriptionAssignment_0_3" |
| // InternalSEW.g:8493:1: rule__Object__DescriptionAssignment_0_3 : ( ruleEString ) ; |
| public final void rule__Object__DescriptionAssignment_0_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8497:1: ( ( ruleEString ) ) |
| // InternalSEW.g:8498:2: ( ruleEString ) |
| { |
| // InternalSEW.g:8498:2: ( ruleEString ) |
| // InternalSEW.g:8499:3: ruleEString |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getDescriptionEStringParserRuleCall_0_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEString(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getDescriptionEStringParserRuleCall_0_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__DescriptionAssignment_0_3" |
| |
| |
| // $ANTLR start "rule__Object__ElementAssignment_0_5" |
| // InternalSEW.g:8508:1: rule__Object__ElementAssignment_0_5 : ( ( rule__Object__ElementAlternatives_0_5_0 ) ) ; |
| public final void rule__Object__ElementAssignment_0_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8512:1: ( ( ( rule__Object__ElementAlternatives_0_5_0 ) ) ) |
| // InternalSEW.g:8513:2: ( ( rule__Object__ElementAlternatives_0_5_0 ) ) |
| { |
| // InternalSEW.g:8513:2: ( ( rule__Object__ElementAlternatives_0_5_0 ) ) |
| // InternalSEW.g:8514:3: ( rule__Object__ElementAlternatives_0_5_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getElementAlternatives_0_5_0()); |
| } |
| // InternalSEW.g:8515:3: ( rule__Object__ElementAlternatives_0_5_0 ) |
| // InternalSEW.g:8515:4: rule__Object__ElementAlternatives_0_5_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__ElementAlternatives_0_5_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getElementAlternatives_0_5_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__ElementAssignment_0_5" |
| |
| |
| // $ANTLR start "rule__Object__NameAssignment_1_1" |
| // InternalSEW.g:8523:1: rule__Object__NameAssignment_1_1 : ( ruleUFI ) ; |
| public final void rule__Object__NameAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8527:1: ( ( ruleUFI ) ) |
| // InternalSEW.g:8528:2: ( ruleUFI ) |
| { |
| // InternalSEW.g:8528:2: ( ruleUFI ) |
| // InternalSEW.g:8529:3: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getNameUFIParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getNameUFIParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__NameAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__Object__TypeAssignment_1_3_0" |
| // InternalSEW.g:8538:1: rule__Object__TypeAssignment_1_3_0 : ( ruleUFI ) ; |
| public final void rule__Object__TypeAssignment_1_3_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8542:1: ( ( ruleUFI ) ) |
| // InternalSEW.g:8543:2: ( ruleUFI ) |
| { |
| // InternalSEW.g:8543:2: ( ruleUFI ) |
| // InternalSEW.g:8544:3: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getTypeUFIParserRuleCall_1_3_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getTypeUFIParserRuleCall_1_3_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__TypeAssignment_1_3_0" |
| |
| |
| // $ANTLR start "rule__Object__DescriptionAssignment_1_3_1" |
| // InternalSEW.g:8553:1: rule__Object__DescriptionAssignment_1_3_1 : ( ruleEString ) ; |
| public final void rule__Object__DescriptionAssignment_1_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8557:1: ( ( ruleEString ) ) |
| // InternalSEW.g:8558:2: ( ruleEString ) |
| { |
| // InternalSEW.g:8558:2: ( ruleEString ) |
| // InternalSEW.g:8559:3: ruleEString |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getDescriptionEStringParserRuleCall_1_3_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEString(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getDescriptionEStringParserRuleCall_1_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__DescriptionAssignment_1_3_1" |
| |
| |
| // $ANTLR start "rule__Object__ElementAssignment_1_5" |
| // InternalSEW.g:8568:1: rule__Object__ElementAssignment_1_5 : ( ( rule__Object__ElementAlternatives_1_5_0 ) ) ; |
| public final void rule__Object__ElementAssignment_1_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8572:1: ( ( ( rule__Object__ElementAlternatives_1_5_0 ) ) ) |
| // InternalSEW.g:8573:2: ( ( rule__Object__ElementAlternatives_1_5_0 ) ) |
| { |
| // InternalSEW.g:8573:2: ( ( rule__Object__ElementAlternatives_1_5_0 ) ) |
| // InternalSEW.g:8574:3: ( rule__Object__ElementAlternatives_1_5_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getObjectAccess().getElementAlternatives_1_5_0()); |
| } |
| // InternalSEW.g:8575:3: ( rule__Object__ElementAlternatives_1_5_0 ) |
| // InternalSEW.g:8575:4: rule__Object__ElementAlternatives_1_5_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Object__ElementAlternatives_1_5_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getObjectAccess().getElementAlternatives_1_5_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Object__ElementAssignment_1_5" |
| |
| |
| // $ANTLR start "rule__Section__NameAssignment_0" |
| // InternalSEW.g:8583:1: rule__Section__NameAssignment_0 : ( ruleXID ) ; |
| public final void rule__Section__NameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8587:1: ( ( ruleXID ) ) |
| // InternalSEW.g:8588:2: ( ruleXID ) |
| { |
| // InternalSEW.g:8588:2: ( ruleXID ) |
| // InternalSEW.g:8589:3: ruleXID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getNameXIDParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleXID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getNameXIDParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__NameAssignment_0" |
| |
| |
| // $ANTLR start "rule__Section__DescriptionAssignment_1" |
| // InternalSEW.g:8598:1: rule__Section__DescriptionAssignment_1 : ( ruleEString ) ; |
| public final void rule__Section__DescriptionAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8602:1: ( ( ruleEString ) ) |
| // InternalSEW.g:8603:2: ( ruleEString ) |
| { |
| // InternalSEW.g:8603:2: ( ruleEString ) |
| // InternalSEW.g:8604:3: ruleEString |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getDescriptionEStringParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEString(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getDescriptionEStringParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__DescriptionAssignment_1" |
| |
| |
| // $ANTLR start "rule__Section__ElementAssignment_2_0_1" |
| // InternalSEW.g:8613:1: rule__Section__ElementAssignment_2_0_1 : ( ( rule__Section__ElementAlternatives_2_0_1_0 ) ) ; |
| public final void rule__Section__ElementAssignment_2_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8617:1: ( ( ( rule__Section__ElementAlternatives_2_0_1_0 ) ) ) |
| // InternalSEW.g:8618:2: ( ( rule__Section__ElementAlternatives_2_0_1_0 ) ) |
| { |
| // InternalSEW.g:8618:2: ( ( rule__Section__ElementAlternatives_2_0_1_0 ) ) |
| // InternalSEW.g:8619:3: ( rule__Section__ElementAlternatives_2_0_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getElementAlternatives_2_0_1_0()); |
| } |
| // InternalSEW.g:8620:3: ( rule__Section__ElementAlternatives_2_0_1_0 ) |
| // InternalSEW.g:8620:4: rule__Section__ElementAlternatives_2_0_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__ElementAlternatives_2_0_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getElementAlternatives_2_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__ElementAssignment_2_0_1" |
| |
| |
| // $ANTLR start "rule__Section__ElementAssignment_2_1_1" |
| // InternalSEW.g:8628:1: rule__Section__ElementAssignment_2_1_1 : ( ( rule__Section__ElementAlternatives_2_1_1_0 ) ) ; |
| public final void rule__Section__ElementAssignment_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8632:1: ( ( ( rule__Section__ElementAlternatives_2_1_1_0 ) ) ) |
| // InternalSEW.g:8633:2: ( ( rule__Section__ElementAlternatives_2_1_1_0 ) ) |
| { |
| // InternalSEW.g:8633:2: ( ( rule__Section__ElementAlternatives_2_1_1_0 ) ) |
| // InternalSEW.g:8634:3: ( rule__Section__ElementAlternatives_2_1_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSectionAccess().getElementAlternatives_2_1_1_0()); |
| } |
| // InternalSEW.g:8635:3: ( rule__Section__ElementAlternatives_2_1_1_0 ) |
| // InternalSEW.g:8635:4: rule__Section__ElementAlternatives_2_1_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__ElementAlternatives_2_1_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSectionAccess().getElementAlternatives_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Section__ElementAssignment_2_1_1" |
| |
| |
| // $ANTLR start "rule__Attribute__NameAssignment_1" |
| // InternalSEW.g:8643:1: rule__Attribute__NameAssignment_1 : ( ruleXID ) ; |
| public final void rule__Attribute__NameAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8647:1: ( ( ruleXID ) ) |
| // InternalSEW.g:8648:2: ( ruleXID ) |
| { |
| // InternalSEW.g:8648:2: ( ruleXID ) |
| // InternalSEW.g:8649:3: ruleXID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAttributeAccess().getNameXIDParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleXID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAttributeAccess().getNameXIDParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__NameAssignment_1" |
| |
| |
| // $ANTLR start "rule__Attribute__ValueAssignment_3" |
| // InternalSEW.g:8658:1: rule__Attribute__ValueAssignment_3 : ( ruleValueSpecification ) ; |
| public final void rule__Attribute__ValueAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8662:1: ( ( ruleValueSpecification ) ) |
| // InternalSEW.g:8663:2: ( ruleValueSpecification ) |
| { |
| // InternalSEW.g:8663:2: ( ruleValueSpecification ) |
| // InternalSEW.g:8664:3: ruleValueSpecification |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAttributeAccess().getValueValueSpecificationParserRuleCall_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleValueSpecification(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAttributeAccess().getValueValueSpecificationParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Attribute__ValueAssignment_3" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__OperatorAssignment_1_1" |
| // InternalSEW.g:8673:1: rule__ConditionalExpression__OperatorAssignment_1_1 : ( ( '?' ) ) ; |
| public final void rule__ConditionalExpression__OperatorAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8677:1: ( ( ( '?' ) ) ) |
| // InternalSEW.g:8678:2: ( ( '?' ) ) |
| { |
| // InternalSEW.g:8678:2: ( ( '?' ) ) |
| // InternalSEW.g:8679:3: ( '?' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getOperatorQuestionMarkKeyword_1_1_0()); |
| } |
| // InternalSEW.g:8680:3: ( '?' ) |
| // InternalSEW.g:8681:4: '?' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getOperatorQuestionMarkKeyword_1_1_0()); |
| } |
| match(input,73,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getOperatorQuestionMarkKeyword_1_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getOperatorQuestionMarkKeyword_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__OperatorAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__OperandAssignment_1_2" |
| // InternalSEW.g:8692:1: rule__ConditionalExpression__OperandAssignment_1_2 : ( ruleExpression ) ; |
| public final void rule__ConditionalExpression__OperandAssignment_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8696:1: ( ( ruleExpression ) ) |
| // InternalSEW.g:8697:2: ( ruleExpression ) |
| { |
| // InternalSEW.g:8697:2: ( ruleExpression ) |
| // InternalSEW.g:8698:3: ruleExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getOperandExpressionParserRuleCall_1_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getOperandExpressionParserRuleCall_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__OperandAssignment_1_2" |
| |
| |
| // $ANTLR start "rule__ConditionalExpression__OperandAssignment_1_4" |
| // InternalSEW.g:8707:1: rule__ConditionalExpression__OperandAssignment_1_4 : ( ruleExpression ) ; |
| public final void rule__ConditionalExpression__OperandAssignment_1_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8711:1: ( ( ruleExpression ) ) |
| // InternalSEW.g:8712:2: ( ruleExpression ) |
| { |
| // InternalSEW.g:8712:2: ( ruleExpression ) |
| // InternalSEW.g:8713:3: ruleExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalExpressionAccess().getOperandExpressionParserRuleCall_1_4_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalExpressionAccess().getOperandExpressionParserRuleCall_1_4_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalExpression__OperandAssignment_1_4" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__OperatorAssignment_1_1" |
| // InternalSEW.g:8722:1: rule__ConditionalOrExpression__OperatorAssignment_1_1 : ( ( rule__ConditionalOrExpression__OperatorAlternatives_1_1_0 ) ) ; |
| public final void rule__ConditionalOrExpression__OperatorAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8726:1: ( ( ( rule__ConditionalOrExpression__OperatorAlternatives_1_1_0 ) ) ) |
| // InternalSEW.g:8727:2: ( ( rule__ConditionalOrExpression__OperatorAlternatives_1_1_0 ) ) |
| { |
| // InternalSEW.g:8727:2: ( ( rule__ConditionalOrExpression__OperatorAlternatives_1_1_0 ) ) |
| // InternalSEW.g:8728:3: ( rule__ConditionalOrExpression__OperatorAlternatives_1_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getOperatorAlternatives_1_1_0()); |
| } |
| // InternalSEW.g:8729:3: ( rule__ConditionalOrExpression__OperatorAlternatives_1_1_0 ) |
| // InternalSEW.g:8729:4: rule__ConditionalOrExpression__OperatorAlternatives_1_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalOrExpression__OperatorAlternatives_1_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getOperatorAlternatives_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__OperatorAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__OperandAssignment_1_2" |
| // InternalSEW.g:8737:1: rule__ConditionalOrExpression__OperandAssignment_1_2 : ( ruleconditionalAndExpression ) ; |
| public final void rule__ConditionalOrExpression__OperandAssignment_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8741:1: ( ( ruleconditionalAndExpression ) ) |
| // InternalSEW.g:8742:2: ( ruleconditionalAndExpression ) |
| { |
| // InternalSEW.g:8742:2: ( ruleconditionalAndExpression ) |
| // InternalSEW.g:8743:3: ruleconditionalAndExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getOperandConditionalAndExpressionParserRuleCall_1_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleconditionalAndExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getOperandConditionalAndExpressionParserRuleCall_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__OperandAssignment_1_2" |
| |
| |
| // $ANTLR start "rule__ConditionalOrExpression__OperandAssignment_1_3_1" |
| // InternalSEW.g:8752:1: rule__ConditionalOrExpression__OperandAssignment_1_3_1 : ( ruleconditionalAndExpression ) ; |
| public final void rule__ConditionalOrExpression__OperandAssignment_1_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8756:1: ( ( ruleconditionalAndExpression ) ) |
| // InternalSEW.g:8757:2: ( ruleconditionalAndExpression ) |
| { |
| // InternalSEW.g:8757:2: ( ruleconditionalAndExpression ) |
| // InternalSEW.g:8758:3: ruleconditionalAndExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalOrExpressionAccess().getOperandConditionalAndExpressionParserRuleCall_1_3_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleconditionalAndExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalOrExpressionAccess().getOperandConditionalAndExpressionParserRuleCall_1_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalOrExpression__OperandAssignment_1_3_1" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__OperatorAssignment_1_1" |
| // InternalSEW.g:8767:1: rule__ConditionalAndExpression__OperatorAssignment_1_1 : ( ( rule__ConditionalAndExpression__OperatorAlternatives_1_1_0 ) ) ; |
| public final void rule__ConditionalAndExpression__OperatorAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8771:1: ( ( ( rule__ConditionalAndExpression__OperatorAlternatives_1_1_0 ) ) ) |
| // InternalSEW.g:8772:2: ( ( rule__ConditionalAndExpression__OperatorAlternatives_1_1_0 ) ) |
| { |
| // InternalSEW.g:8772:2: ( ( rule__ConditionalAndExpression__OperatorAlternatives_1_1_0 ) ) |
| // InternalSEW.g:8773:3: ( rule__ConditionalAndExpression__OperatorAlternatives_1_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getOperatorAlternatives_1_1_0()); |
| } |
| // InternalSEW.g:8774:3: ( rule__ConditionalAndExpression__OperatorAlternatives_1_1_0 ) |
| // InternalSEW.g:8774:4: rule__ConditionalAndExpression__OperatorAlternatives_1_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ConditionalAndExpression__OperatorAlternatives_1_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getOperatorAlternatives_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__OperatorAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__OperandAssignment_1_2" |
| // InternalSEW.g:8782:1: rule__ConditionalAndExpression__OperandAssignment_1_2 : ( ruleequalityExpression ) ; |
| public final void rule__ConditionalAndExpression__OperandAssignment_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8786:1: ( ( ruleequalityExpression ) ) |
| // InternalSEW.g:8787:2: ( ruleequalityExpression ) |
| { |
| // InternalSEW.g:8787:2: ( ruleequalityExpression ) |
| // InternalSEW.g:8788:3: ruleequalityExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getOperandEqualityExpressionParserRuleCall_1_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleequalityExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getOperandEqualityExpressionParserRuleCall_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__OperandAssignment_1_2" |
| |
| |
| // $ANTLR start "rule__ConditionalAndExpression__OperandAssignment_1_3_1" |
| // InternalSEW.g:8797:1: rule__ConditionalAndExpression__OperandAssignment_1_3_1 : ( ruleequalityExpression ) ; |
| public final void rule__ConditionalAndExpression__OperandAssignment_1_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8801:1: ( ( ruleequalityExpression ) ) |
| // InternalSEW.g:8802:2: ( ruleequalityExpression ) |
| { |
| // InternalSEW.g:8802:2: ( ruleequalityExpression ) |
| // InternalSEW.g:8803:3: ruleequalityExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getConditionalAndExpressionAccess().getOperandEqualityExpressionParserRuleCall_1_3_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleequalityExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getConditionalAndExpressionAccess().getOperandEqualityExpressionParserRuleCall_1_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ConditionalAndExpression__OperandAssignment_1_3_1" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__OperatorAssignment_1_1" |
| // InternalSEW.g:8812:1: rule__EqualityExpression__OperatorAssignment_1_1 : ( ( rule__EqualityExpression__OperatorAlternatives_1_1_0 ) ) ; |
| public final void rule__EqualityExpression__OperatorAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8816:1: ( ( ( rule__EqualityExpression__OperatorAlternatives_1_1_0 ) ) ) |
| // InternalSEW.g:8817:2: ( ( rule__EqualityExpression__OperatorAlternatives_1_1_0 ) ) |
| { |
| // InternalSEW.g:8817:2: ( ( rule__EqualityExpression__OperatorAlternatives_1_1_0 ) ) |
| // InternalSEW.g:8818:3: ( rule__EqualityExpression__OperatorAlternatives_1_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getOperatorAlternatives_1_1_0()); |
| } |
| // InternalSEW.g:8819:3: ( rule__EqualityExpression__OperatorAlternatives_1_1_0 ) |
| // InternalSEW.g:8819:4: rule__EqualityExpression__OperatorAlternatives_1_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EqualityExpression__OperatorAlternatives_1_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getOperatorAlternatives_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__OperatorAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__EqualityExpression__OperandAssignment_1_2" |
| // InternalSEW.g:8827:1: rule__EqualityExpression__OperandAssignment_1_2 : ( rulerelationalExpression ) ; |
| public final void rule__EqualityExpression__OperandAssignment_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8831:1: ( ( rulerelationalExpression ) ) |
| // InternalSEW.g:8832:2: ( rulerelationalExpression ) |
| { |
| // InternalSEW.g:8832:2: ( rulerelationalExpression ) |
| // InternalSEW.g:8833:3: rulerelationalExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEqualityExpressionAccess().getOperandRelationalExpressionParserRuleCall_1_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulerelationalExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEqualityExpressionAccess().getOperandRelationalExpressionParserRuleCall_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EqualityExpression__OperandAssignment_1_2" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__OperatorAssignment_1_1" |
| // InternalSEW.g:8842:1: rule__RelationalExpression__OperatorAssignment_1_1 : ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ; |
| public final void rule__RelationalExpression__OperatorAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8846:1: ( ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ) |
| // InternalSEW.g:8847:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) |
| { |
| // InternalSEW.g:8847:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) |
| // InternalSEW.g:8848:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); |
| } |
| // InternalSEW.g:8849:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) |
| // InternalSEW.g:8849:4: rule__RelationalExpression__OperatorAlternatives_1_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RelationalExpression__OperatorAlternatives_1_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__OperatorAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__RelationalExpression__OperandAssignment_1_2" |
| // InternalSEW.g:8857:1: rule__RelationalExpression__OperandAssignment_1_2 : ( ruleadditiveExpression ) ; |
| public final void rule__RelationalExpression__OperandAssignment_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8861:1: ( ( ruleadditiveExpression ) ) |
| // InternalSEW.g:8862:2: ( ruleadditiveExpression ) |
| { |
| // InternalSEW.g:8862:2: ( ruleadditiveExpression ) |
| // InternalSEW.g:8863:3: ruleadditiveExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRelationalExpressionAccess().getOperandAdditiveExpressionParserRuleCall_1_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleadditiveExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRelationalExpressionAccess().getOperandAdditiveExpressionParserRuleCall_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RelationalExpression__OperandAssignment_1_2" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__OperatorAssignment_1_1" |
| // InternalSEW.g:8872:1: rule__AdditiveExpression__OperatorAssignment_1_1 : ( ( '+' ) ) ; |
| public final void rule__AdditiveExpression__OperatorAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8876:1: ( ( ( '+' ) ) ) |
| // InternalSEW.g:8877:2: ( ( '+' ) ) |
| { |
| // InternalSEW.g:8877:2: ( ( '+' ) ) |
| // InternalSEW.g:8878:3: ( '+' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getOperatorPlusSignKeyword_1_1_0()); |
| } |
| // InternalSEW.g:8879:3: ( '+' ) |
| // InternalSEW.g:8880:4: '+' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getOperatorPlusSignKeyword_1_1_0()); |
| } |
| match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getOperatorPlusSignKeyword_1_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getOperatorPlusSignKeyword_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__OperatorAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__OperandAssignment_1_2" |
| // InternalSEW.g:8891:1: rule__AdditiveExpression__OperandAssignment_1_2 : ( rulemultiplicativeExpression ) ; |
| public final void rule__AdditiveExpression__OperandAssignment_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8895:1: ( ( rulemultiplicativeExpression ) ) |
| // InternalSEW.g:8896:2: ( rulemultiplicativeExpression ) |
| { |
| // InternalSEW.g:8896:2: ( rulemultiplicativeExpression ) |
| // InternalSEW.g:8897:3: rulemultiplicativeExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getOperandMultiplicativeExpressionParserRuleCall_1_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulemultiplicativeExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getOperandMultiplicativeExpressionParserRuleCall_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__OperandAssignment_1_2" |
| |
| |
| // $ANTLR start "rule__AdditiveExpression__OperandAssignment_1_3_1" |
| // InternalSEW.g:8906:1: rule__AdditiveExpression__OperandAssignment_1_3_1 : ( rulemultiplicativeExpression ) ; |
| public final void rule__AdditiveExpression__OperandAssignment_1_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8910:1: ( ( rulemultiplicativeExpression ) ) |
| // InternalSEW.g:8911:2: ( rulemultiplicativeExpression ) |
| { |
| // InternalSEW.g:8911:2: ( rulemultiplicativeExpression ) |
| // InternalSEW.g:8912:3: rulemultiplicativeExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getAdditiveExpressionAccess().getOperandMultiplicativeExpressionParserRuleCall_1_3_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulemultiplicativeExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getAdditiveExpressionAccess().getOperandMultiplicativeExpressionParserRuleCall_1_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AdditiveExpression__OperandAssignment_1_3_1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperatorAssignment_1_0_1" |
| // InternalSEW.g:8921:1: rule__MultiplicativeExpression__OperatorAssignment_1_0_1 : ( ( '*' ) ) ; |
| public final void rule__MultiplicativeExpression__OperatorAssignment_1_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8925:1: ( ( ( '*' ) ) ) |
| // InternalSEW.g:8926:2: ( ( '*' ) ) |
| { |
| // InternalSEW.g:8926:2: ( ( '*' ) ) |
| // InternalSEW.g:8927:3: ( '*' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskKeyword_1_0_1_0()); |
| } |
| // InternalSEW.g:8928:3: ( '*' ) |
| // InternalSEW.g:8929:4: '*' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskKeyword_1_0_1_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskKeyword_1_0_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskKeyword_1_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperatorAssignment_1_0_1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperandAssignment_1_0_2" |
| // InternalSEW.g:8940:1: rule__MultiplicativeExpression__OperandAssignment_1_0_2 : ( ruleprimaryExpression ) ; |
| public final void rule__MultiplicativeExpression__OperandAssignment_1_0_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8944:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:8945:2: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:8945:2: ( ruleprimaryExpression ) |
| // InternalSEW.g:8946:3: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_0_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_0_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperandAssignment_1_0_2" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperandAssignment_1_0_3_1" |
| // InternalSEW.g:8955:1: rule__MultiplicativeExpression__OperandAssignment_1_0_3_1 : ( ruleprimaryExpression ) ; |
| public final void rule__MultiplicativeExpression__OperandAssignment_1_0_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8959:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:8960:2: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:8960:2: ( ruleprimaryExpression ) |
| // InternalSEW.g:8961:3: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_0_3_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_0_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperandAssignment_1_0_3_1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperatorAssignment_1_1_1" |
| // InternalSEW.g:8970:1: rule__MultiplicativeExpression__OperatorAssignment_1_1_1 : ( ( '**' ) ) ; |
| public final void rule__MultiplicativeExpression__OperatorAssignment_1_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8974:1: ( ( ( '**' ) ) ) |
| // InternalSEW.g:8975:2: ( ( '**' ) ) |
| { |
| // InternalSEW.g:8975:2: ( ( '**' ) ) |
| // InternalSEW.g:8976:3: ( '**' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_1_0()); |
| } |
| // InternalSEW.g:8977:3: ( '**' ) |
| // InternalSEW.g:8978:4: '**' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_1_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAsteriskAsteriskKeyword_1_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperatorAssignment_1_1_1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperandAssignment_1_1_2" |
| // InternalSEW.g:8989:1: rule__MultiplicativeExpression__OperandAssignment_1_1_2 : ( ruleprimaryExpression ) ; |
| public final void rule__MultiplicativeExpression__OperandAssignment_1_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:8993:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:8994:2: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:8994:2: ( ruleprimaryExpression ) |
| // InternalSEW.g:8995:3: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_1_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperandAssignment_1_1_2" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperandAssignment_1_1_3_1" |
| // InternalSEW.g:9004:1: rule__MultiplicativeExpression__OperandAssignment_1_1_3_1 : ( ruleprimaryExpression ) ; |
| public final void rule__MultiplicativeExpression__OperandAssignment_1_1_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9008:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:9009:2: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:9009:2: ( ruleprimaryExpression ) |
| // InternalSEW.g:9010:3: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_1_3_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_1_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperandAssignment_1_1_3_1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperatorAssignment_1_2_1" |
| // InternalSEW.g:9019:1: rule__MultiplicativeExpression__OperatorAssignment_1_2_1 : ( ( '/' ) ) ; |
| public final void rule__MultiplicativeExpression__OperatorAssignment_1_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9023:1: ( ( ( '/' ) ) ) |
| // InternalSEW.g:9024:2: ( ( '/' ) ) |
| { |
| // InternalSEW.g:9024:2: ( ( '/' ) ) |
| // InternalSEW.g:9025:3: ( '/' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorSolidusKeyword_1_2_1_0()); |
| } |
| // InternalSEW.g:9026:3: ( '/' ) |
| // InternalSEW.g:9027:4: '/' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorSolidusKeyword_1_2_1_0()); |
| } |
| match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorSolidusKeyword_1_2_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorSolidusKeyword_1_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperatorAssignment_1_2_1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperandAssignment_1_2_2" |
| // InternalSEW.g:9038:1: rule__MultiplicativeExpression__OperandAssignment_1_2_2 : ( ruleprimaryExpression ) ; |
| public final void rule__MultiplicativeExpression__OperandAssignment_1_2_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9042:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:9043:2: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:9043:2: ( ruleprimaryExpression ) |
| // InternalSEW.g:9044:3: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_2_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_2_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperandAssignment_1_2_2" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperandAssignment_1_2_3_1" |
| // InternalSEW.g:9053:1: rule__MultiplicativeExpression__OperandAssignment_1_2_3_1 : ( ruleprimaryExpression ) ; |
| public final void rule__MultiplicativeExpression__OperandAssignment_1_2_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9057:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:9058:2: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:9058:2: ( ruleprimaryExpression ) |
| // InternalSEW.g:9059:3: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_2_3_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_2_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperandAssignment_1_2_3_1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperatorAssignment_1_3_1" |
| // InternalSEW.g:9068:1: rule__MultiplicativeExpression__OperatorAssignment_1_3_1 : ( ( '%' ) ) ; |
| public final void rule__MultiplicativeExpression__OperatorAssignment_1_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9072:1: ( ( ( '%' ) ) ) |
| // InternalSEW.g:9073:2: ( ( '%' ) ) |
| { |
| // InternalSEW.g:9073:2: ( ( '%' ) ) |
| // InternalSEW.g:9074:3: ( '%' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorPercentSignKeyword_1_3_1_0()); |
| } |
| // InternalSEW.g:9075:3: ( '%' ) |
| // InternalSEW.g:9076:4: '%' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorPercentSignKeyword_1_3_1_0()); |
| } |
| match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorPercentSignKeyword_1_3_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorPercentSignKeyword_1_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperatorAssignment_1_3_1" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperandAssignment_1_3_2" |
| // InternalSEW.g:9087:1: rule__MultiplicativeExpression__OperandAssignment_1_3_2 : ( ruleprimaryExpression ) ; |
| public final void rule__MultiplicativeExpression__OperandAssignment_1_3_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9091:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:9092:2: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:9092:2: ( ruleprimaryExpression ) |
| // InternalSEW.g:9093:3: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_3_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_3_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperandAssignment_1_3_2" |
| |
| |
| // $ANTLR start "rule__MultiplicativeExpression__OperandAssignment_1_3_3_1" |
| // InternalSEW.g:9102:1: rule__MultiplicativeExpression__OperandAssignment_1_3_3_1 : ( ruleprimaryExpression ) ; |
| public final void rule__MultiplicativeExpression__OperandAssignment_1_3_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9106:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:9107:2: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:9107:2: ( ruleprimaryExpression ) |
| // InternalSEW.g:9108:3: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_3_3_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicativeExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_3_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicativeExpression__OperandAssignment_1_3_3_1" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__OperatorAssignment_1_1_0" |
| // InternalSEW.g:9117:1: rule__PrimaryExpression__OperatorAssignment_1_1_0 : ( ( '-' ) ) ; |
| public final void rule__PrimaryExpression__OperatorAssignment_1_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9121:1: ( ( ( '-' ) ) ) |
| // InternalSEW.g:9122:2: ( ( '-' ) ) |
| { |
| // InternalSEW.g:9122:2: ( ( '-' ) ) |
| // InternalSEW.g:9123:3: ( '-' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getOperatorHyphenMinusKeyword_1_1_0_0()); |
| } |
| // InternalSEW.g:9124:3: ( '-' ) |
| // InternalSEW.g:9125:4: '-' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getOperatorHyphenMinusKeyword_1_1_0_0()); |
| } |
| match(input,69,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getOperatorHyphenMinusKeyword_1_1_0_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getOperatorHyphenMinusKeyword_1_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__OperatorAssignment_1_1_0" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__OperandAssignment_1_1_1" |
| // InternalSEW.g:9136:1: rule__PrimaryExpression__OperandAssignment_1_1_1 : ( ruleprimaryExpression ) ; |
| public final void rule__PrimaryExpression__OperandAssignment_1_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9140:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:9141:2: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:9141:2: ( ruleprimaryExpression ) |
| // InternalSEW.g:9142:3: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getOperandPrimaryExpressionParserRuleCall_1_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__OperandAssignment_1_1_1" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__OperatorAssignment_2_1_0" |
| // InternalSEW.g:9151:1: rule__PrimaryExpression__OperatorAssignment_2_1_0 : ( ( rule__PrimaryExpression__OperatorAlternatives_2_1_0_0 ) ) ; |
| public final void rule__PrimaryExpression__OperatorAssignment_2_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9155:1: ( ( ( rule__PrimaryExpression__OperatorAlternatives_2_1_0_0 ) ) ) |
| // InternalSEW.g:9156:2: ( ( rule__PrimaryExpression__OperatorAlternatives_2_1_0_0 ) ) |
| { |
| // InternalSEW.g:9156:2: ( ( rule__PrimaryExpression__OperatorAlternatives_2_1_0_0 ) ) |
| // InternalSEW.g:9157:3: ( rule__PrimaryExpression__OperatorAlternatives_2_1_0_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getOperatorAlternatives_2_1_0_0()); |
| } |
| // InternalSEW.g:9158:3: ( rule__PrimaryExpression__OperatorAlternatives_2_1_0_0 ) |
| // InternalSEW.g:9158:4: rule__PrimaryExpression__OperatorAlternatives_2_1_0_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__OperatorAlternatives_2_1_0_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getOperatorAlternatives_2_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__OperatorAssignment_2_1_0" |
| |
| |
| // $ANTLR start "rule__PrimaryExpression__OperandAssignment_2_1_1" |
| // InternalSEW.g:9166:1: rule__PrimaryExpression__OperandAssignment_2_1_1 : ( ruleprimaryExpression ) ; |
| public final void rule__PrimaryExpression__OperandAssignment_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9170:1: ( ( ruleprimaryExpression ) ) |
| // InternalSEW.g:9171:2: ( ruleprimaryExpression ) |
| { |
| // InternalSEW.g:9171:2: ( ruleprimaryExpression ) |
| // InternalSEW.g:9172:3: ruleprimaryExpression |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getOperandPrimaryExpressionParserRuleCall_2_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleprimaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpressionAccess().getOperandPrimaryExpressionParserRuleCall_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpression__OperandAssignment_2_1_1" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__ValuesAssignment_2_0" |
| // InternalSEW.g:9181:1: rule__LiteralArrayValue__ValuesAssignment_2_0 : ( ruleValueSpecification ) ; |
| public final void rule__LiteralArrayValue__ValuesAssignment_2_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9185:1: ( ( ruleValueSpecification ) ) |
| // InternalSEW.g:9186:2: ( ruleValueSpecification ) |
| { |
| // InternalSEW.g:9186:2: ( ruleValueSpecification ) |
| // InternalSEW.g:9187:3: ruleValueSpecification |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueAccess().getValuesValueSpecificationParserRuleCall_2_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleValueSpecification(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueAccess().getValuesValueSpecificationParserRuleCall_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__ValuesAssignment_2_0" |
| |
| |
| // $ANTLR start "rule__LiteralArrayValue__ValuesAssignment_2_1_1" |
| // InternalSEW.g:9196:1: rule__LiteralArrayValue__ValuesAssignment_2_1_1 : ( ruleValueSpecification ) ; |
| public final void rule__LiteralArrayValue__ValuesAssignment_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9200:1: ( ( ruleValueSpecification ) ) |
| // InternalSEW.g:9201:2: ( ruleValueSpecification ) |
| { |
| // InternalSEW.g:9201:2: ( ruleValueSpecification ) |
| // InternalSEW.g:9202:3: ruleValueSpecification |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralArrayValueAccess().getValuesValueSpecificationParserRuleCall_2_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleValueSpecification(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralArrayValueAccess().getValuesValueSpecificationParserRuleCall_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralArrayValue__ValuesAssignment_2_1_1" |
| |
| |
| // $ANTLR start "rule__LiteralObjectReference__ObjectAssignment_1_0" |
| // InternalSEW.g:9211:1: rule__LiteralObjectReference__ObjectAssignment_1_0 : ( ( ruleUFI ) ) ; |
| public final void rule__LiteralObjectReference__ObjectAssignment_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9215:1: ( ( ( ruleUFI ) ) ) |
| // InternalSEW.g:9216:2: ( ( ruleUFI ) ) |
| { |
| // InternalSEW.g:9216:2: ( ( ruleUFI ) ) |
| // InternalSEW.g:9217:3: ( ruleUFI ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralObjectReferenceAccess().getObjectWObjectCrossReference_1_0_0()); |
| } |
| // InternalSEW.g:9218:3: ( ruleUFI ) |
| // InternalSEW.g:9219:4: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralObjectReferenceAccess().getObjectWObjectUFIParserRuleCall_1_0_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralObjectReferenceAccess().getObjectWObjectUFIParserRuleCall_1_0_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralObjectReferenceAccess().getObjectWObjectCrossReference_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralObjectReference__ObjectAssignment_1_0" |
| |
| |
| // $ANTLR start "rule__LiteralObjectReference__SymbolAssignment_1_1" |
| // InternalSEW.g:9230:1: rule__LiteralObjectReference__SymbolAssignment_1_1 : ( ruleUFI ) ; |
| public final void rule__LiteralObjectReference__SymbolAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9234:1: ( ( ruleUFI ) ) |
| // InternalSEW.g:9235:2: ( ruleUFI ) |
| { |
| // InternalSEW.g:9235:2: ( ruleUFI ) |
| // InternalSEW.g:9236:3: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralObjectReferenceAccess().getSymbolUFIParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralObjectReferenceAccess().getSymbolUFIParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralObjectReference__SymbolAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__LiteralBooleanValue__ValueAssignment" |
| // InternalSEW.g:9245:1: rule__LiteralBooleanValue__ValueAssignment : ( ruleEBoolean ) ; |
| public final void rule__LiteralBooleanValue__ValueAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9249:1: ( ( ruleEBoolean ) ) |
| // InternalSEW.g:9250:2: ( ruleEBoolean ) |
| { |
| // InternalSEW.g:9250:2: ( ruleEBoolean ) |
| // InternalSEW.g:9251:3: ruleEBoolean |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralBooleanValueAccess().getValueEBooleanParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEBoolean(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralBooleanValueAccess().getValueEBooleanParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralBooleanValue__ValueAssignment" |
| |
| |
| // $ANTLR start "rule__LiteralCharacterValue__ValueAssignment" |
| // InternalSEW.g:9260:1: rule__LiteralCharacterValue__ValueAssignment : ( ruleEChar ) ; |
| public final void rule__LiteralCharacterValue__ValueAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9264:1: ( ( ruleEChar ) ) |
| // InternalSEW.g:9265:2: ( ruleEChar ) |
| { |
| // InternalSEW.g:9265:2: ( ruleEChar ) |
| // InternalSEW.g:9266:3: ruleEChar |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralCharacterValueAccess().getValueECharParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEChar(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralCharacterValueAccess().getValueECharParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralCharacterValue__ValueAssignment" |
| |
| |
| // $ANTLR start "rule__LiteralIntegerValue__ValueAssignment" |
| // InternalSEW.g:9275:1: rule__LiteralIntegerValue__ValueAssignment : ( ruleELong ) ; |
| public final void rule__LiteralIntegerValue__ValueAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9279:1: ( ( ruleELong ) ) |
| // InternalSEW.g:9280:2: ( ruleELong ) |
| { |
| // InternalSEW.g:9280:2: ( ruleELong ) |
| // InternalSEW.g:9281:3: ruleELong |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralIntegerValueAccess().getValueELongParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleELong(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralIntegerValueAccess().getValueELongParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralIntegerValue__ValueAssignment" |
| |
| |
| // $ANTLR start "rule__LiteralRationalValue__NumeratorAssignment_0" |
| // InternalSEW.g:9290:1: rule__LiteralRationalValue__NumeratorAssignment_0 : ( ruleELong ) ; |
| public final void rule__LiteralRationalValue__NumeratorAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9294:1: ( ( ruleELong ) ) |
| // InternalSEW.g:9295:2: ( ruleELong ) |
| { |
| // InternalSEW.g:9295:2: ( ruleELong ) |
| // InternalSEW.g:9296:3: ruleELong |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralRationalValueAccess().getNumeratorELongParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleELong(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralRationalValueAccess().getNumeratorELongParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralRationalValue__NumeratorAssignment_0" |
| |
| |
| // $ANTLR start "rule__LiteralRationalValue__DenominatorAssignment_2" |
| // InternalSEW.g:9305:1: rule__LiteralRationalValue__DenominatorAssignment_2 : ( ruleELong ) ; |
| public final void rule__LiteralRationalValue__DenominatorAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9309:1: ( ( ruleELong ) ) |
| // InternalSEW.g:9310:2: ( ruleELong ) |
| { |
| // InternalSEW.g:9310:2: ( ruleELong ) |
| // InternalSEW.g:9311:3: ruleELong |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralRationalValueAccess().getDenominatorELongParserRuleCall_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleELong(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralRationalValueAccess().getDenominatorELongParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralRationalValue__DenominatorAssignment_2" |
| |
| |
| // $ANTLR start "rule__LiteralFloatValue__ValueAssignment" |
| // InternalSEW.g:9320:1: rule__LiteralFloatValue__ValueAssignment : ( ruleEDouble ) ; |
| public final void rule__LiteralFloatValue__ValueAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9324:1: ( ( ruleEDouble ) ) |
| // InternalSEW.g:9325:2: ( ruleEDouble ) |
| { |
| // InternalSEW.g:9325:2: ( ruleEDouble ) |
| // InternalSEW.g:9326:3: ruleEDouble |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralFloatValueAccess().getValueEDoubleParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEDouble(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralFloatValueAccess().getValueEDoubleParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralFloatValue__ValueAssignment" |
| |
| |
| // $ANTLR start "rule__LiteralStringValue__ValueAssignment" |
| // InternalSEW.g:9335:1: rule__LiteralStringValue__ValueAssignment : ( ruleEString ) ; |
| public final void rule__LiteralStringValue__ValueAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9339:1: ( ( ruleEString ) ) |
| // InternalSEW.g:9340:2: ( ruleEString ) |
| { |
| // InternalSEW.g:9340:2: ( ruleEString ) |
| // InternalSEW.g:9341:3: ruleEString |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralStringValueAccess().getValueEStringParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEString(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralStringValueAccess().getValueEStringParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralStringValue__ValueAssignment" |
| |
| |
| // $ANTLR start "rule__LiteralNullValue__TypeAssignment_2_1" |
| // InternalSEW.g:9350:1: rule__LiteralNullValue__TypeAssignment_2_1 : ( ruleXID ) ; |
| public final void rule__LiteralNullValue__TypeAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9354:1: ( ( ruleXID ) ) |
| // InternalSEW.g:9355:2: ( ruleXID ) |
| { |
| // InternalSEW.g:9355:2: ( ruleXID ) |
| // InternalSEW.g:9356:3: ruleXID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralNullValueAccess().getTypeXIDParserRuleCall_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleXID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralNullValueAccess().getTypeXIDParserRuleCall_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralNullValue__TypeAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__LiteralTimeVariable__SymbolAssignment_1" |
| // InternalSEW.g:9365:1: rule__LiteralTimeVariable__SymbolAssignment_1 : ( ( '$time' ) ) ; |
| public final void rule__LiteralTimeVariable__SymbolAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9369:1: ( ( ( '$time' ) ) ) |
| // InternalSEW.g:9370:2: ( ( '$time' ) ) |
| { |
| // InternalSEW.g:9370:2: ( ( '$time' ) ) |
| // InternalSEW.g:9371:3: ( '$time' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeVariableAccess().getSymbolTimeKeyword_1_0()); |
| } |
| // InternalSEW.g:9372:3: ( '$time' ) |
| // InternalSEW.g:9373:4: '$time' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeVariableAccess().getSymbolTimeKeyword_1_0()); |
| } |
| match(input,74,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeVariableAccess().getSymbolTimeKeyword_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeVariableAccess().getSymbolTimeKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralTimeVariable__SymbolAssignment_1" |
| |
| |
| // $ANTLR start "rule__LiteralTimeDeltaVariable__SymbolAssignment_1" |
| // InternalSEW.g:9384:1: rule__LiteralTimeDeltaVariable__SymbolAssignment_1 : ( ( '$delta' ) ) ; |
| public final void rule__LiteralTimeDeltaVariable__SymbolAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9388:1: ( ( ( '$delta' ) ) ) |
| // InternalSEW.g:9389:2: ( ( '$delta' ) ) |
| { |
| // InternalSEW.g:9389:2: ( ( '$delta' ) ) |
| // InternalSEW.g:9390:3: ( '$delta' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeDeltaVariableAccess().getSymbolDeltaKeyword_1_0()); |
| } |
| // InternalSEW.g:9391:3: ( '$delta' ) |
| // InternalSEW.g:9392:4: '$delta' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralTimeDeltaVariableAccess().getSymbolDeltaKeyword_1_0()); |
| } |
| match(input,75,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeDeltaVariableAccess().getSymbolDeltaKeyword_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralTimeDeltaVariableAccess().getSymbolDeltaKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralTimeDeltaVariable__SymbolAssignment_1" |
| |
| |
| // $ANTLR start "rule__LiteralThisInstance__SymbolAssignment_1" |
| // InternalSEW.g:9403:1: rule__LiteralThisInstance__SymbolAssignment_1 : ( ( '$this' ) ) ; |
| public final void rule__LiteralThisInstance__SymbolAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9407:1: ( ( ( '$this' ) ) ) |
| // InternalSEW.g:9408:2: ( ( '$this' ) ) |
| { |
| // InternalSEW.g:9408:2: ( ( '$this' ) ) |
| // InternalSEW.g:9409:3: ( '$this' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralThisInstanceAccess().getSymbolThisKeyword_1_0()); |
| } |
| // InternalSEW.g:9410:3: ( '$this' ) |
| // InternalSEW.g:9411:4: '$this' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralThisInstanceAccess().getSymbolThisKeyword_1_0()); |
| } |
| match(input,76,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralThisInstanceAccess().getSymbolThisKeyword_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralThisInstanceAccess().getSymbolThisKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralThisInstance__SymbolAssignment_1" |
| |
| |
| // $ANTLR start "rule__LiteralSelfInstance__SymbolAssignment_1" |
| // InternalSEW.g:9422:1: rule__LiteralSelfInstance__SymbolAssignment_1 : ( ( '$self' ) ) ; |
| public final void rule__LiteralSelfInstance__SymbolAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9426:1: ( ( ( '$self' ) ) ) |
| // InternalSEW.g:9427:2: ( ( '$self' ) ) |
| { |
| // InternalSEW.g:9427:2: ( ( '$self' ) ) |
| // InternalSEW.g:9428:3: ( '$self' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSelfInstanceAccess().getSymbolSelfKeyword_1_0()); |
| } |
| // InternalSEW.g:9429:3: ( '$self' ) |
| // InternalSEW.g:9430:4: '$self' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSelfInstanceAccess().getSymbolSelfKeyword_1_0()); |
| } |
| match(input,77,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSelfInstanceAccess().getSymbolSelfKeyword_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSelfInstanceAccess().getSymbolSelfKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSelfInstance__SymbolAssignment_1" |
| |
| |
| // $ANTLR start "rule__LiteralParentInstance__SymbolAssignment_1" |
| // InternalSEW.g:9441:1: rule__LiteralParentInstance__SymbolAssignment_1 : ( ( '$parent' ) ) ; |
| public final void rule__LiteralParentInstance__SymbolAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9445:1: ( ( ( '$parent' ) ) ) |
| // InternalSEW.g:9446:2: ( ( '$parent' ) ) |
| { |
| // InternalSEW.g:9446:2: ( ( '$parent' ) ) |
| // InternalSEW.g:9447:3: ( '$parent' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralParentInstanceAccess().getSymbolParentKeyword_1_0()); |
| } |
| // InternalSEW.g:9448:3: ( '$parent' ) |
| // InternalSEW.g:9449:4: '$parent' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralParentInstanceAccess().getSymbolParentKeyword_1_0()); |
| } |
| match(input,78,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralParentInstanceAccess().getSymbolParentKeyword_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralParentInstanceAccess().getSymbolParentKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralParentInstance__SymbolAssignment_1" |
| |
| |
| // $ANTLR start "rule__LiteralSuperInstance__SymbolAssignment_1" |
| // InternalSEW.g:9460:1: rule__LiteralSuperInstance__SymbolAssignment_1 : ( ( '$super' ) ) ; |
| public final void rule__LiteralSuperInstance__SymbolAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9464:1: ( ( ( '$super' ) ) ) |
| // InternalSEW.g:9465:2: ( ( '$super' ) ) |
| { |
| // InternalSEW.g:9465:2: ( ( '$super' ) ) |
| // InternalSEW.g:9466:3: ( '$super' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSuperInstanceAccess().getSymbolSuperKeyword_1_0()); |
| } |
| // InternalSEW.g:9467:3: ( '$super' ) |
| // InternalSEW.g:9468:4: '$super' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSuperInstanceAccess().getSymbolSuperKeyword_1_0()); |
| } |
| match(input,79,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSuperInstanceAccess().getSymbolSuperKeyword_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSuperInstanceAccess().getSymbolSuperKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSuperInstance__SymbolAssignment_1" |
| |
| |
| // $ANTLR start "rule__LiteralSystemInstance__SymbolAssignment_1" |
| // InternalSEW.g:9479:1: rule__LiteralSystemInstance__SymbolAssignment_1 : ( ( '$system' ) ) ; |
| public final void rule__LiteralSystemInstance__SymbolAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9483:1: ( ( ( '$system' ) ) ) |
| // InternalSEW.g:9484:2: ( ( '$system' ) ) |
| { |
| // InternalSEW.g:9484:2: ( ( '$system' ) ) |
| // InternalSEW.g:9485:3: ( '$system' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSystemInstanceAccess().getSymbolSystemKeyword_1_0()); |
| } |
| // InternalSEW.g:9486:3: ( '$system' ) |
| // InternalSEW.g:9487:4: '$system' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralSystemInstanceAccess().getSymbolSystemKeyword_1_0()); |
| } |
| match(input,80,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSystemInstanceAccess().getSymbolSystemKeyword_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralSystemInstanceAccess().getSymbolSystemKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralSystemInstance__SymbolAssignment_1" |
| |
| |
| // $ANTLR start "rule__LiteralEnvInstance__SymbolAssignment_1" |
| // InternalSEW.g:9498:1: rule__LiteralEnvInstance__SymbolAssignment_1 : ( ( rule__LiteralEnvInstance__SymbolAlternatives_1_0 ) ) ; |
| public final void rule__LiteralEnvInstance__SymbolAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9502:1: ( ( ( rule__LiteralEnvInstance__SymbolAlternatives_1_0 ) ) ) |
| // InternalSEW.g:9503:2: ( ( rule__LiteralEnvInstance__SymbolAlternatives_1_0 ) ) |
| { |
| // InternalSEW.g:9503:2: ( ( rule__LiteralEnvInstance__SymbolAlternatives_1_0 ) ) |
| // InternalSEW.g:9504:3: ( rule__LiteralEnvInstance__SymbolAlternatives_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralEnvInstanceAccess().getSymbolAlternatives_1_0()); |
| } |
| // InternalSEW.g:9505:3: ( rule__LiteralEnvInstance__SymbolAlternatives_1_0 ) |
| // InternalSEW.g:9505:4: rule__LiteralEnvInstance__SymbolAlternatives_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralEnvInstance__SymbolAlternatives_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLiteralEnvInstanceAccess().getSymbolAlternatives_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralEnvInstance__SymbolAssignment_1" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__NameAssignment_0_2" |
| // InternalSEW.g:9513:1: rule__DeprecatedObject__NameAssignment_0_2 : ( ruleUFI ) ; |
| public final void rule__DeprecatedObject__NameAssignment_0_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9517:1: ( ( ruleUFI ) ) |
| // InternalSEW.g:9518:2: ( ruleUFI ) |
| { |
| // InternalSEW.g:9518:2: ( ruleUFI ) |
| // InternalSEW.g:9519:3: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getNameUFIParserRuleCall_0_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getNameUFIParserRuleCall_0_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__NameAssignment_0_2" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__DescriptionAssignment_0_3" |
| // InternalSEW.g:9528:1: rule__DeprecatedObject__DescriptionAssignment_0_3 : ( ruleEString ) ; |
| public final void rule__DeprecatedObject__DescriptionAssignment_0_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9532:1: ( ( ruleEString ) ) |
| // InternalSEW.g:9533:2: ( ruleEString ) |
| { |
| // InternalSEW.g:9533:2: ( ruleEString ) |
| // InternalSEW.g:9534:3: ruleEString |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getDescriptionEStringParserRuleCall_0_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEString(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getDescriptionEStringParserRuleCall_0_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__DescriptionAssignment_0_3" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__TypeAssignment_0_6" |
| // InternalSEW.g:9543:1: rule__DeprecatedObject__TypeAssignment_0_6 : ( ruleUFI ) ; |
| public final void rule__DeprecatedObject__TypeAssignment_0_6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9547:1: ( ( ruleUFI ) ) |
| // InternalSEW.g:9548:2: ( ruleUFI ) |
| { |
| // InternalSEW.g:9548:2: ( ruleUFI ) |
| // InternalSEW.g:9549:3: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getTypeUFIParserRuleCall_0_6_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getTypeUFIParserRuleCall_0_6_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__TypeAssignment_0_6" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__ElementAssignment_0_8" |
| // InternalSEW.g:9558:1: rule__DeprecatedObject__ElementAssignment_0_8 : ( ruleDeprecatedProperty ) ; |
| public final void rule__DeprecatedObject__ElementAssignment_0_8() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9562:1: ( ( ruleDeprecatedProperty ) ) |
| // InternalSEW.g:9563:2: ( ruleDeprecatedProperty ) |
| { |
| // InternalSEW.g:9563:2: ( ruleDeprecatedProperty ) |
| // InternalSEW.g:9564:3: ruleDeprecatedProperty |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getElementDeprecatedPropertyParserRuleCall_0_8_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedProperty(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getElementDeprecatedPropertyParserRuleCall_0_8_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__ElementAssignment_0_8" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__NameAssignment_1_2" |
| // InternalSEW.g:9573:1: rule__DeprecatedObject__NameAssignment_1_2 : ( ruleUFI ) ; |
| public final void rule__DeprecatedObject__NameAssignment_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9577:1: ( ( ruleUFI ) ) |
| // InternalSEW.g:9578:2: ( ruleUFI ) |
| { |
| // InternalSEW.g:9578:2: ( ruleUFI ) |
| // InternalSEW.g:9579:3: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getNameUFIParserRuleCall_1_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getNameUFIParserRuleCall_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__NameAssignment_1_2" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__DescriptionAssignment_1_3" |
| // InternalSEW.g:9588:1: rule__DeprecatedObject__DescriptionAssignment_1_3 : ( ruleEString ) ; |
| public final void rule__DeprecatedObject__DescriptionAssignment_1_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9592:1: ( ( ruleEString ) ) |
| // InternalSEW.g:9593:2: ( ruleEString ) |
| { |
| // InternalSEW.g:9593:2: ( ruleEString ) |
| // InternalSEW.g:9594:3: ruleEString |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getDescriptionEStringParserRuleCall_1_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEString(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getDescriptionEStringParserRuleCall_1_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__DescriptionAssignment_1_3" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__TypeAssignment_1_6" |
| // InternalSEW.g:9603:1: rule__DeprecatedObject__TypeAssignment_1_6 : ( ruleUFI ) ; |
| public final void rule__DeprecatedObject__TypeAssignment_1_6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9607:1: ( ( ruleUFI ) ) |
| // InternalSEW.g:9608:2: ( ruleUFI ) |
| { |
| // InternalSEW.g:9608:2: ( ruleUFI ) |
| // InternalSEW.g:9609:3: ruleUFI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getTypeUFIParserRuleCall_1_6_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUFI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getTypeUFIParserRuleCall_1_6_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__TypeAssignment_1_6" |
| |
| |
| // $ANTLR start "rule__DeprecatedObject__ElementAssignment_1_8" |
| // InternalSEW.g:9618:1: rule__DeprecatedObject__ElementAssignment_1_8 : ( ruleDeprecatedProperty ) ; |
| public final void rule__DeprecatedObject__ElementAssignment_1_8() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9622:1: ( ( ruleDeprecatedProperty ) ) |
| // InternalSEW.g:9623:2: ( ruleDeprecatedProperty ) |
| { |
| // InternalSEW.g:9623:2: ( ruleDeprecatedProperty ) |
| // InternalSEW.g:9624:3: ruleDeprecatedProperty |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedObjectAccess().getElementDeprecatedPropertyParserRuleCall_1_8_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedProperty(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedObjectAccess().getElementDeprecatedPropertyParserRuleCall_1_8_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedObject__ElementAssignment_1_8" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__NameAssignment_0_2" |
| // InternalSEW.g:9633:1: rule__DeprecatedSection__NameAssignment_0_2 : ( ruleXID ) ; |
| public final void rule__DeprecatedSection__NameAssignment_0_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9637:1: ( ( ruleXID ) ) |
| // InternalSEW.g:9638:2: ( ruleXID ) |
| { |
| // InternalSEW.g:9638:2: ( ruleXID ) |
| // InternalSEW.g:9639:3: ruleXID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getNameXIDParserRuleCall_0_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleXID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getNameXIDParserRuleCall_0_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__NameAssignment_0_2" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__ElementAssignment_0_3" |
| // InternalSEW.g:9648:1: rule__DeprecatedSection__ElementAssignment_0_3 : ( ( rule__DeprecatedSection__ElementAlternatives_0_3_0 ) ) ; |
| public final void rule__DeprecatedSection__ElementAssignment_0_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9652:1: ( ( ( rule__DeprecatedSection__ElementAlternatives_0_3_0 ) ) ) |
| // InternalSEW.g:9653:2: ( ( rule__DeprecatedSection__ElementAlternatives_0_3_0 ) ) |
| { |
| // InternalSEW.g:9653:2: ( ( rule__DeprecatedSection__ElementAlternatives_0_3_0 ) ) |
| // InternalSEW.g:9654:3: ( rule__DeprecatedSection__ElementAlternatives_0_3_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementAlternatives_0_3_0()); |
| } |
| // InternalSEW.g:9655:3: ( rule__DeprecatedSection__ElementAlternatives_0_3_0 ) |
| // InternalSEW.g:9655:4: rule__DeprecatedSection__ElementAlternatives_0_3_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__ElementAlternatives_0_3_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementAlternatives_0_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__ElementAssignment_0_3" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__NameAssignment_1_0" |
| // InternalSEW.g:9663:1: rule__DeprecatedSection__NameAssignment_1_0 : ( ruleXID ) ; |
| public final void rule__DeprecatedSection__NameAssignment_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9667:1: ( ( ruleXID ) ) |
| // InternalSEW.g:9668:2: ( ruleXID ) |
| { |
| // InternalSEW.g:9668:2: ( ruleXID ) |
| // InternalSEW.g:9669:3: ruleXID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getNameXIDParserRuleCall_1_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleXID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getNameXIDParserRuleCall_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__NameAssignment_1_0" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__DescriptionAssignment_1_1" |
| // InternalSEW.g:9678:1: rule__DeprecatedSection__DescriptionAssignment_1_1 : ( ruleEString ) ; |
| public final void rule__DeprecatedSection__DescriptionAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9682:1: ( ( ruleEString ) ) |
| // InternalSEW.g:9683:2: ( ruleEString ) |
| { |
| // InternalSEW.g:9683:2: ( ruleEString ) |
| // InternalSEW.g:9684:3: ruleEString |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getDescriptionEStringParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEString(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getDescriptionEStringParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__DescriptionAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__ElementAssignment_1_2_0_1" |
| // InternalSEW.g:9693:1: rule__DeprecatedSection__ElementAssignment_1_2_0_1 : ( ( rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0 ) ) ; |
| public final void rule__DeprecatedSection__ElementAssignment_1_2_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9697:1: ( ( ( rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0 ) ) ) |
| // InternalSEW.g:9698:2: ( ( rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0 ) ) |
| { |
| // InternalSEW.g:9698:2: ( ( rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0 ) ) |
| // InternalSEW.g:9699:3: ( rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementAlternatives_1_2_0_1_0()); |
| } |
| // InternalSEW.g:9700:3: ( rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0 ) |
| // InternalSEW.g:9700:4: rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementAlternatives_1_2_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__ElementAssignment_1_2_0_1" |
| |
| |
| // $ANTLR start "rule__DeprecatedSection__ElementAssignment_1_2_1_1" |
| // InternalSEW.g:9708:1: rule__DeprecatedSection__ElementAssignment_1_2_1_1 : ( ( rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0 ) ) ; |
| public final void rule__DeprecatedSection__ElementAssignment_1_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9712:1: ( ( ( rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0 ) ) ) |
| // InternalSEW.g:9713:2: ( ( rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0 ) ) |
| { |
| // InternalSEW.g:9713:2: ( ( rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0 ) ) |
| // InternalSEW.g:9714:3: ( rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedSectionAccess().getElementAlternatives_1_2_1_1_0()); |
| } |
| // InternalSEW.g:9715:3: ( rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0 ) |
| // InternalSEW.g:9715:4: rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedSectionAccess().getElementAlternatives_1_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedSection__ElementAssignment_1_2_1_1" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__NameAssignment_1" |
| // InternalSEW.g:9723:1: rule__DeprecatedAttribute__NameAssignment_1 : ( ruleDeprecatedAttributeID ) ; |
| public final void rule__DeprecatedAttribute__NameAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9727:1: ( ( ruleDeprecatedAttributeID ) ) |
| // InternalSEW.g:9728:2: ( ruleDeprecatedAttributeID ) |
| { |
| // InternalSEW.g:9728:2: ( ruleDeprecatedAttributeID ) |
| // InternalSEW.g:9729:3: ruleDeprecatedAttributeID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeAccess().getNameDeprecatedAttributeIDParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleDeprecatedAttributeID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeAccess().getNameDeprecatedAttributeIDParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__NameAssignment_1" |
| |
| |
| // $ANTLR start "rule__DeprecatedAttribute__ValueAssignment_3" |
| // InternalSEW.g:9738:1: rule__DeprecatedAttribute__ValueAssignment_3 : ( ruleValueSpecification ) ; |
| public final void rule__DeprecatedAttribute__ValueAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9742:1: ( ( ruleValueSpecification ) ) |
| // InternalSEW.g:9743:2: ( ruleValueSpecification ) |
| { |
| // InternalSEW.g:9743:2: ( ruleValueSpecification ) |
| // InternalSEW.g:9744:3: ruleValueSpecification |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedAttributeAccess().getValueValueSpecificationParserRuleCall_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleValueSpecification(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedAttributeAccess().getValueValueSpecificationParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedAttribute__ValueAssignment_3" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__OperatorAssignment_2" |
| // InternalSEW.g:9753:1: rule__DeprecatedExpression__OperatorAssignment_2 : ( ( rule__DeprecatedExpression__OperatorAlternatives_2_0 ) ) ; |
| public final void rule__DeprecatedExpression__OperatorAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9757:1: ( ( ( rule__DeprecatedExpression__OperatorAlternatives_2_0 ) ) ) |
| // InternalSEW.g:9758:2: ( ( rule__DeprecatedExpression__OperatorAlternatives_2_0 ) ) |
| { |
| // InternalSEW.g:9758:2: ( ( rule__DeprecatedExpression__OperatorAlternatives_2_0 ) ) |
| // InternalSEW.g:9759:3: ( rule__DeprecatedExpression__OperatorAlternatives_2_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedExpressionAccess().getOperatorAlternatives_2_0()); |
| } |
| // InternalSEW.g:9760:3: ( rule__DeprecatedExpression__OperatorAlternatives_2_0 ) |
| // InternalSEW.g:9760:4: rule__DeprecatedExpression__OperatorAlternatives_2_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedExpression__OperatorAlternatives_2_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedExpressionAccess().getOperatorAlternatives_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__OperatorAssignment_2" |
| |
| |
| // $ANTLR start "rule__DeprecatedExpression__OperandAssignment_3" |
| // InternalSEW.g:9768:1: rule__DeprecatedExpression__OperandAssignment_3 : ( ruleValueSpecification ) ; |
| public final void rule__DeprecatedExpression__OperandAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalSEW.g:9772:1: ( ( ruleValueSpecification ) ) |
| // InternalSEW.g:9773:2: ( ruleValueSpecification ) |
| { |
| // InternalSEW.g:9773:2: ( ruleValueSpecification ) |
| // InternalSEW.g:9774:3: ruleValueSpecification |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getDeprecatedExpressionAccess().getOperandValueSpecificationParserRuleCall_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleValueSpecification(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getDeprecatedExpressionAccess().getOperandValueSpecificationParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DeprecatedExpression__OperandAssignment_3" |
| |
| // $ANTLR start synpred1_InternalSEW |
| public final void synpred1_InternalSEW_fragment() throws RecognitionException { |
| // InternalSEW.g:1370:2: ( ( ( rule__Workflow__Group_2_0__0 ) ) ) |
| // InternalSEW.g:1370:2: ( ( rule__Workflow__Group_2_0__0 ) ) |
| { |
| // InternalSEW.g:1370:2: ( ( rule__Workflow__Group_2_0__0 ) ) |
| // InternalSEW.g:1371:3: ( rule__Workflow__Group_2_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getGroup_2_0()); |
| } |
| // InternalSEW.g:1372:3: ( rule__Workflow__Group_2_0__0 ) |
| // InternalSEW.g:1372:4: rule__Workflow__Group_2_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Workflow__Group_2_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred1_InternalSEW |
| |
| // $ANTLR start synpred3_InternalSEW |
| public final void synpred3_InternalSEW_fragment() throws RecognitionException { |
| // InternalSEW.g:1376:2: ( ( ( rule__Workflow__ElementAssignment_2_1 )* ) ) |
| // InternalSEW.g:1376:2: ( ( rule__Workflow__ElementAssignment_2_1 )* ) |
| { |
| // InternalSEW.g:1376:2: ( ( rule__Workflow__ElementAssignment_2_1 )* ) |
| // InternalSEW.g:1377:3: ( rule__Workflow__ElementAssignment_2_1 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWorkflowAccess().getElementAssignment_2_1()); |
| } |
| // InternalSEW.g:1378:3: ( rule__Workflow__ElementAssignment_2_1 )* |
| loop98: |
| do { |
| int alt98=2; |
| int LA98_0 = input.LA(1); |
| |
| if ( (LA98_0==RULE_XIDENDIFIER||LA98_0==14||LA98_0==18||(LA98_0>=42 && LA98_0<=47)) ) { |
| alt98=1; |
| } |
| |
| |
| switch (alt98) { |
| case 1 : |
| // InternalSEW.g:1378:4: rule__Workflow__ElementAssignment_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_3); |
| rule__Workflow__ElementAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop98; |
| } |
| } while (true); |
| |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred3_InternalSEW |
| |
| // $ANTLR start synpred39_InternalSEW |
| public final void synpred39_InternalSEW_fragment() throws RecognitionException { |
| // InternalSEW.g:1982:2: ( ( ( rule__PrimaryExpression__Group_1__0 ) ) ) |
| // InternalSEW.g:1982:2: ( ( rule__PrimaryExpression__Group_1__0 ) ) |
| { |
| // InternalSEW.g:1982:2: ( ( rule__PrimaryExpression__Group_1__0 ) ) |
| // InternalSEW.g:1983:3: ( rule__PrimaryExpression__Group_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpressionAccess().getGroup_1()); |
| } |
| // InternalSEW.g:1984:3: ( rule__PrimaryExpression__Group_1__0 ) |
| // InternalSEW.g:1984:4: rule__PrimaryExpression__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpression__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred39_InternalSEW |
| |
| // $ANTLR start synpred45_InternalSEW |
| public final void synpred45_InternalSEW_fragment() throws RecognitionException { |
| // InternalSEW.g:2048:2: ( ( ruleLiteralIntegerValue ) ) |
| // InternalSEW.g:2048:2: ( ruleLiteralIntegerValue ) |
| { |
| // InternalSEW.g:2048:2: ( ruleLiteralIntegerValue ) |
| // InternalSEW.g:2049:3: ruleLiteralIntegerValue |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralIntegerValueParserRuleCall_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralIntegerValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred45_InternalSEW |
| |
| // $ANTLR start synpred47_InternalSEW |
| public final void synpred47_InternalSEW_fragment() throws RecognitionException { |
| // InternalSEW.g:2060:2: ( ( ruleLiteralFloatValue ) ) |
| // InternalSEW.g:2060:2: ( ruleLiteralFloatValue ) |
| { |
| // InternalSEW.g:2060:2: ( ruleLiteralFloatValue ) |
| // InternalSEW.g:2061:3: ruleLiteralFloatValue |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralExpressionAccess().getLiteralFloatValueParserRuleCall_4()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLiteralFloatValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred47_InternalSEW |
| |
| // $ANTLR start synpred53_InternalSEW |
| public final void synpred53_InternalSEW_fragment() throws RecognitionException { |
| // InternalSEW.g:2111:2: ( ( ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) ) ) |
| // InternalSEW.g:2111:2: ( ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) ) |
| { |
| // InternalSEW.g:2111:2: ( ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) ) |
| // InternalSEW.g:2112:3: ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLiteralObjectReferenceAccess().getObjectAssignment_1_0()); |
| } |
| // InternalSEW.g:2113:3: ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) |
| // InternalSEW.g:2113:4: rule__LiteralObjectReference__ObjectAssignment_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LiteralObjectReference__ObjectAssignment_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred53_InternalSEW |
| |
| // $ANTLR start synpred94_InternalSEW |
| public final void synpred94_InternalSEW_fragment() throws RecognitionException { |
| // InternalSEW.g:3693:3: ( rule__Section__ElementAssignment_2_1_1 ) |
| // InternalSEW.g:3693:3: rule__Section__ElementAssignment_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Section__ElementAssignment_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred94_InternalSEW |
| |
| // $ANTLR start synpred103_InternalSEW |
| public final void synpred103_InternalSEW_fragment() throws RecognitionException { |
| // InternalSEW.g:4773:3: ( rule__AdditiveExpression__Group_1__0 ) |
| // InternalSEW.g:4773:3: rule__AdditiveExpression__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred103_InternalSEW |
| |
| // $ANTLR start synpred104_InternalSEW |
| public final void synpred104_InternalSEW_fragment() throws RecognitionException { |
| // InternalSEW.g:4881:3: ( rule__AdditiveExpression__Group_1_3__0 ) |
| // InternalSEW.g:4881:3: rule__AdditiveExpression__Group_1_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__AdditiveExpression__Group_1_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred104_InternalSEW |
| |
| // $ANTLR start synpred125_InternalSEW |
| public final void synpred125_InternalSEW_fragment() throws RecognitionException { |
| // InternalSEW.g:7878:3: ( ruleXID ) |
| // InternalSEW.g:7878:3: ruleXID |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleXID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred125_InternalSEW |
| |
| // $ANTLR start synpred128_InternalSEW |
| public final void synpred128_InternalSEW_fragment() throws RecognitionException { |
| // InternalSEW.g:8094:3: ( rule__DeprecatedSection__ElementAssignment_1_2_1_1 ) |
| // InternalSEW.g:8094:3: rule__DeprecatedSection__ElementAssignment_1_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__DeprecatedSection__ElementAssignment_1_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred128_InternalSEW |
| |
| // Delegated rules |
| |
| public final boolean synpred45_InternalSEW() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred45_InternalSEW_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred47_InternalSEW() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred47_InternalSEW_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred128_InternalSEW() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred128_InternalSEW_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred39_InternalSEW() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred39_InternalSEW_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred1_InternalSEW() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred1_InternalSEW_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred53_InternalSEW() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred53_InternalSEW_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred103_InternalSEW() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred103_InternalSEW_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred3_InternalSEW() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred3_InternalSEW_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred94_InternalSEW() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred94_InternalSEW_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred104_InternalSEW() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred104_InternalSEW_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred125_InternalSEW() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred125_InternalSEW_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| |
| |
| protected DFA2 dfa2 = new DFA2(this); |
| protected DFA4 dfa4 = new DFA4(this); |
| protected DFA5 dfa5 = new DFA5(this); |
| protected DFA12 dfa12 = new DFA12(this); |
| protected DFA13 dfa13 = new DFA13(this); |
| protected DFA15 dfa15 = new DFA15(this); |
| protected DFA16 dfa16 = new DFA16(this); |
| protected DFA18 dfa18 = new DFA18(this); |
| protected DFA19 dfa19 = new DFA19(this); |
| protected DFA30 dfa30 = new DFA30(this); |
| protected DFA31 dfa31 = new DFA31(this); |
| protected DFA38 dfa38 = new DFA38(this); |
| protected DFA40 dfa40 = new DFA40(this); |
| protected DFA42 dfa42 = new DFA42(this); |
| protected DFA43 dfa43 = new DFA43(this); |
| protected DFA61 dfa61 = new DFA61(this); |
| protected DFA70 dfa70 = new DFA70(this); |
| protected DFA71 dfa71 = new DFA71(this); |
| protected DFA80 dfa80 = new DFA80(this); |
| protected DFA91 dfa91 = new DFA91(this); |
| protected DFA92 dfa92 = new DFA92(this); |
| protected DFA95 dfa95 = new DFA95(this); |
| static final String dfa_1s = "\15\uffff"; |
| static final String dfa_2s = "\1\3\14\uffff"; |
| static final String dfa_3s = "\1\6\1\0\2\uffff\1\0\1\uffff\1\0\6\uffff"; |
| static final String dfa_4s = "\1\57\1\0\2\uffff\1\0\1\uffff\1\0\6\uffff"; |
| static final String dfa_5s = "\2\uffff\1\1\1\2\10\uffff\1\3"; |
| static final String dfa_6s = "\1\uffff\1\0\2\uffff\1\1\1\uffff\1\2\6\uffff}>"; |
| static final String[] dfa_7s = { |
| "\1\3\7\uffff\1\1\1\2\2\uffff\1\3\27\uffff\1\4\1\3\1\6\3\3", |
| "\1\uffff", |
| "", |
| "", |
| "\1\uffff", |
| "", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| 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 DFA2 extends DFA { |
| |
| public DFA2(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 2; |
| 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 "1365:1: rule__Workflow__Alternatives_2 : ( ( ( rule__Workflow__Group_2_0__0 ) ) | ( ( rule__Workflow__ElementAssignment_2_1 )* ) | ( ( rule__Workflow__ElementAssignment_2_2 ) ) );"; |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA2_1 = input.LA(1); |
| |
| |
| int index2_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred1_InternalSEW()) ) {s = 2;} |
| |
| else if ( (synpred3_InternalSEW()) ) {s = 3;} |
| |
| |
| input.seek(index2_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA2_4 = input.LA(1); |
| |
| |
| int index2_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred3_InternalSEW()) ) {s = 3;} |
| |
| else if ( (true) ) {s = 12;} |
| |
| |
| input.seek(index2_4); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA2_6 = input.LA(1); |
| |
| |
| int index2_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred3_InternalSEW()) ) {s = 3;} |
| |
| else if ( (true) ) {s = 12;} |
| |
| |
| input.seek(index2_6); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 2, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String dfa_8s = "\1\6\11\5\1\uffff\1\62\1\uffff"; |
| static final String dfa_9s = "\1\57\11\72\1\uffff\1\71\1\uffff"; |
| static final String dfa_10s = "\12\uffff\1\1\1\uffff\1\2"; |
| static final String dfa_11s = "\15\uffff}>"; |
| static final String[] dfa_12s = { |
| "\1\11\7\uffff\1\1\3\uffff\1\2\27\uffff\1\3\1\4\1\5\1\6\1\7\1\10", |
| "\1\13\1\12\7\uffff\1\12\3\uffff\5\12\23\uffff\6\12\2\uffff\1\12\4\uffff\1\14\1\uffff\2\14", |
| "\1\13\1\12\7\uffff\1\12\3\uffff\5\12\23\uffff\6\12\2\uffff\1\12\4\uffff\1\14\1\uffff\2\14", |
| "\1\13\1\12\7\uffff\1\12\3\uffff\5\12\23\uffff\6\12\2\uffff\1\12\4\uffff\1\14\1\uffff\2\14", |
| "\1\13\1\12\7\uffff\1\12\3\uffff\5\12\23\uffff\6\12\2\uffff\1\12\4\uffff\1\14\1\uffff\2\14", |
| "\1\13\1\12\7\uffff\1\12\3\uffff\5\12\23\uffff\6\12\2\uffff\1\12\4\uffff\1\14\1\uffff\2\14", |
| "\1\13\1\12\7\uffff\1\12\3\uffff\5\12\23\uffff\6\12\2\uffff\1\12\4\uffff\1\14\1\uffff\2\14", |
| "\1\13\1\12\7\uffff\1\12\3\uffff\5\12\23\uffff\6\12\2\uffff\1\12\4\uffff\1\14\1\uffff\2\14", |
| "\1\13\1\12\7\uffff\1\12\3\uffff\5\12\23\uffff\6\12\2\uffff\1\12\4\uffff\1\14\1\uffff\2\14", |
| "\1\13\1\12\7\uffff\1\12\3\uffff\5\12\23\uffff\6\12\2\uffff\1\12\4\uffff\1\14\1\uffff\2\14", |
| "", |
| "\1\12\4\uffff\1\14\1\uffff\1\14", |
| "" |
| }; |
| static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s); |
| static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); |
| static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s); |
| static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); |
| static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s); |
| |
| class DFA4 extends DFA { |
| |
| public DFA4(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 4; |
| this.eot = dfa_1; |
| this.eof = dfa_1; |
| this.min = dfa_8; |
| this.max = dfa_9; |
| this.accept = dfa_10; |
| this.special = dfa_11; |
| this.transition = dfa_12; |
| } |
| public String getDescription() { |
| return "1413:1: rule__Workflow__ElementAlternatives_2_0_4_0 : ( ( ruleObject ) | ( ruleProperty ) );"; |
| } |
| } |
| static final String dfa_13s = "\1\6\11\5\1\62\2\uffff"; |
| static final String dfa_14s = "\1\57\11\72\1\71\2\uffff"; |
| static final String dfa_15s = "\13\uffff\1\2\1\1"; |
| static final String[] dfa_16s = { |
| "\1\11\7\uffff\1\1\3\uffff\1\2\27\uffff\1\3\1\4\1\5\1\6\1\7\1\10", |
| "\1\12\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\13\1\uffff\2\13", |
| "\1\12\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\13\1\uffff\2\13", |
| "\1\12\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\13\1\uffff\2\13", |
| "\1\12\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\13\1\uffff\2\13", |
| "\1\12\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\13\1\uffff\2\13", |
| "\1\12\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\13\1\uffff\2\13", |
| "\1\12\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\13\1\uffff\2\13", |
| "\1\12\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\13\1\uffff\2\13", |
| "\1\12\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\13\1\uffff\2\13", |
| "\1\14\4\uffff\1\13\1\uffff\1\13", |
| "", |
| "" |
| }; |
| static final char[] dfa_13 = DFA.unpackEncodedStringToUnsignedChars(dfa_13s); |
| static final char[] dfa_14 = DFA.unpackEncodedStringToUnsignedChars(dfa_14s); |
| static final short[] dfa_15 = DFA.unpackEncodedString(dfa_15s); |
| static final short[][] dfa_16 = unpackEncodedStringArray(dfa_16s); |
| |
| class DFA5 extends DFA { |
| |
| public DFA5(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 5; |
| this.eot = dfa_1; |
| this.eof = dfa_1; |
| this.min = dfa_13; |
| this.max = dfa_14; |
| this.accept = dfa_15; |
| this.special = dfa_11; |
| this.transition = dfa_16; |
| } |
| public String getDescription() { |
| return "1434:1: rule__Workflow__ElementAlternatives_2_1_0 : ( ( ruleObject ) | ( ruleProperty ) );"; |
| } |
| } |
| static final String dfa_17s = "\27\uffff"; |
| static final String dfa_18s = "\1\6\11\5\2\6\2\uffff\11\5"; |
| static final String dfa_19s = "\1\57\11\62\2\57\2\uffff\11\62"; |
| static final String dfa_20s = "\14\uffff\1\2\1\1\11\uffff"; |
| static final String dfa_21s = "\27\uffff}>"; |
| static final String[] dfa_22s = { |
| "\1\11\7\uffff\1\1\3\uffff\1\2\27\uffff\1\3\1\4\1\5\1\6\1\7\1\10", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\1\26\7\uffff\1\16\3\uffff\1\17\27\uffff\1\20\1\21\1\22\1\23\1\24\1\25", |
| "\1\26\7\uffff\1\16\3\uffff\1\17\27\uffff\1\20\1\21\1\22\1\23\1\24\1\25", |
| "", |
| "", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15", |
| "\2\15\7\uffff\1\15\3\uffff\1\15\1\12\1\13\2\14\23\uffff\6\15\2\uffff\1\15" |
| }; |
| |
| static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); |
| static final char[] dfa_18 = DFA.unpackEncodedStringToUnsignedChars(dfa_18s); |
| static final char[] dfa_19 = DFA.unpackEncodedStringToUnsignedChars(dfa_19s); |
| static final short[] dfa_20 = DFA.unpackEncodedString(dfa_20s); |
| static final short[] dfa_21 = DFA.unpackEncodedString(dfa_21s); |
| static final short[][] dfa_22 = unpackEncodedStringArray(dfa_22s); |
| |
| class DFA12 extends DFA { |
| |
| public DFA12(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 12; |
| this.eot = dfa_17; |
| this.eof = dfa_17; |
| this.min = dfa_18; |
| this.max = dfa_19; |
| this.accept = dfa_20; |
| this.special = dfa_21; |
| this.transition = dfa_22; |
| } |
| public String getDescription() { |
| return "1593:1: rule__Object__Alternatives : ( ( ( rule__Object__Group_0__0 ) ) | ( ( rule__Object__Group_1__0 ) ) );"; |
| } |
| } |
| static final String dfa_23s = "\12\uffff\1\2\1\uffff\1\1"; |
| static final String[] dfa_24s = { |
| "\1\11\7\uffff\1\1\3\uffff\1\2\27\uffff\1\3\1\4\1\5\1\6\1\7\1\10", |
| "\1\13\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\12\1\uffff\2\12", |
| "\1\13\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\12\1\uffff\2\12", |
| "\1\13\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\12\1\uffff\2\12", |
| "\1\13\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\12\1\uffff\2\12", |
| "\1\13\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\12\1\uffff\2\12", |
| "\1\13\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\12\1\uffff\2\12", |
| "\1\13\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\12\1\uffff\2\12", |
| "\1\13\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\12\1\uffff\2\12", |
| "\1\13\1\14\7\uffff\1\14\3\uffff\5\14\23\uffff\6\14\2\uffff\1\14\4\uffff\1\12\1\uffff\2\12", |
| "", |
| "\1\14\4\uffff\1\12\1\uffff\1\12", |
| "" |
| }; |
| static final short[] dfa_23 = DFA.unpackEncodedString(dfa_23s); |
| static final short[][] dfa_24 = unpackEncodedStringArray(dfa_24s); |
| |
| class DFA13 extends DFA { |
| |
| public DFA13(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 13; |
| this.eot = dfa_1; |
| this.eof = dfa_1; |
| this.min = dfa_8; |
| this.max = dfa_9; |
| this.accept = dfa_23; |
| this.special = dfa_11; |
| this.transition = dfa_24; |
| } |
| public String getDescription() { |
| return "1614:1: rule__Object__ElementAlternatives_0_5_0 : ( ( ruleObject ) | ( ruleProperty ) );"; |
| } |
| } |
| |
| class DFA15 extends DFA { |
| |
| public DFA15(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 15; |
| this.eot = dfa_1; |
| this.eof = dfa_1; |
| this.min = dfa_8; |
| this.max = dfa_9; |
| this.accept = dfa_10; |
| this.special = dfa_11; |
| this.transition = dfa_12; |
| } |
| public String getDescription() { |
| return "1656:1: rule__Object__ElementAlternatives_1_5_0 : ( ( ruleObject ) | ( ruleProperty ) );"; |
| } |
| } |
| static final String dfa_25s = "\14\uffff"; |
| static final String dfa_26s = "\1\6\11\5\2\uffff"; |
| static final String dfa_27s = "\1\57\11\72\2\uffff"; |
| static final String dfa_28s = "\12\uffff\1\2\1\1"; |
| static final String dfa_29s = "\14\uffff}>"; |
| static final String[] dfa_30s = { |
| "\1\11\7\uffff\1\1\3\uffff\1\2\27\uffff\1\3\1\4\1\5\1\6\1\7\1\10", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "", |
| "" |
| }; |
| |
| static final short[] dfa_25 = DFA.unpackEncodedString(dfa_25s); |
| static final char[] dfa_26 = DFA.unpackEncodedStringToUnsignedChars(dfa_26s); |
| static final char[] dfa_27 = DFA.unpackEncodedStringToUnsignedChars(dfa_27s); |
| static final short[] dfa_28 = DFA.unpackEncodedString(dfa_28s); |
| static final short[] dfa_29 = DFA.unpackEncodedString(dfa_29s); |
| static final short[][] dfa_30 = unpackEncodedStringArray(dfa_30s); |
| |
| class DFA16 extends DFA { |
| |
| public DFA16(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 16; |
| this.eot = dfa_25; |
| this.eof = dfa_25; |
| this.min = dfa_26; |
| this.max = dfa_27; |
| this.accept = dfa_28; |
| this.special = dfa_29; |
| this.transition = dfa_30; |
| } |
| public String getDescription() { |
| return "1677:1: rule__Property__Alternatives : ( ( ruleSection ) | ( ruleAttribute ) );"; |
| } |
| } |
| static final String[] dfa_31s = { |
| "\1\11\7\uffff\1\1\3\uffff\1\2\27\uffff\1\3\1\4\1\5\1\6\1\7\1\10", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "", |
| "" |
| }; |
| static final short[][] dfa_31 = unpackEncodedStringArray(dfa_31s); |
| |
| class DFA18 extends DFA { |
| |
| public DFA18(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 18; |
| this.eot = dfa_25; |
| this.eof = dfa_25; |
| this.min = dfa_26; |
| this.max = dfa_27; |
| this.accept = dfa_28; |
| this.special = dfa_29; |
| this.transition = dfa_31; |
| } |
| public String getDescription() { |
| return "1719:1: rule__Section__ElementAlternatives_2_0_1_0 : ( ( ruleObject ) | ( ruleAttribute ) );"; |
| } |
| } |
| |
| class DFA19 extends DFA { |
| |
| public DFA19(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 19; |
| this.eot = dfa_25; |
| this.eof = dfa_25; |
| this.min = dfa_26; |
| this.max = dfa_27; |
| this.accept = dfa_28; |
| this.special = dfa_29; |
| this.transition = dfa_31; |
| } |
| public String getDescription() { |
| return "1740:1: rule__Section__ElementAlternatives_2_1_1_0 : ( ( ruleObject ) | ( ruleAttribute ) );"; |
| } |
| } |
| static final String dfa_32s = "\16\uffff"; |
| static final String dfa_33s = "\1\4\2\uffff\1\10\1\77\11\uffff"; |
| static final String dfa_34s = "\1\120\2\uffff\1\24\1\77\11\uffff"; |
| static final String dfa_35s = "\1\uffff\1\1\1\2\2\uffff\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\4\1\3"; |
| static final String dfa_36s = "\4\uffff\1\0\11\uffff}>"; |
| static final String[] dfa_37s = { |
| "\1\2\1\6\1\11\1\uffff\1\4\5\uffff\1\11\3\uffff\1\11\1\uffff\1\5\21\uffff\2\13\2\1\6\11\7\uffff\1\10\13\uffff\1\11\1\7\1\3\4\uffff\2\12\5\13", |
| "", |
| "", |
| "\1\4\13\uffff\1\5", |
| "\1\14", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] dfa_32 = DFA.unpackEncodedString(dfa_32s); |
| static final char[] dfa_33 = DFA.unpackEncodedStringToUnsignedChars(dfa_33s); |
| static final char[] dfa_34 = DFA.unpackEncodedStringToUnsignedChars(dfa_34s); |
| static final short[] dfa_35 = DFA.unpackEncodedString(dfa_35s); |
| static final short[] dfa_36 = DFA.unpackEncodedString(dfa_36s); |
| static final short[][] dfa_37 = unpackEncodedStringArray(dfa_37s); |
| |
| class DFA30 extends DFA { |
| |
| public DFA30(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 30; |
| this.eot = dfa_32; |
| this.eof = dfa_32; |
| this.min = dfa_33; |
| this.max = dfa_34; |
| this.accept = dfa_35; |
| this.special = dfa_36; |
| this.transition = dfa_37; |
| } |
| public String getDescription() { |
| return "2031:1: rule__LiteralExpression__Alternatives : ( ( ruleLiteralBooleanValue ) | ( ruleLiteralCharacterValue ) | ( ruleLiteralIntegerValue ) | ( ruleLiteralRationalValue ) | ( ruleLiteralFloatValue ) | ( ruleLiteralStringValue ) | ( ruleLiteralNullValue ) | ( ruleLiteralArrayValue ) | ( ruleLiteralObjectReference ) | ( ruleLiteralVariableReference ) | ( ruleLiteralInstanceReference ) );"; |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA30_4 = input.LA(1); |
| |
| |
| int index30_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (LA30_4==63) ) {s = 12;} |
| |
| else if ( (synpred45_InternalSEW()) ) {s = 13;} |
| |
| else if ( (synpred47_InternalSEW()) ) {s = 5;} |
| |
| |
| input.seek(index30_4); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 30, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String dfa_38s = "\1\6\11\0\2\uffff"; |
| static final String dfa_39s = "\1\57\11\0\2\uffff"; |
| static final String dfa_40s = "\12\uffff\1\1\1\2"; |
| static final String dfa_41s = "\1\uffff\1\2\1\4\1\0\1\3\1\5\1\6\1\1\1\7\1\10\2\uffff}>"; |
| static final String[] dfa_42s = { |
| "\1\11\7\uffff\1\1\3\uffff\1\2\27\uffff\1\3\1\4\1\5\1\6\1\7\1\10", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "" |
| }; |
| static final char[] dfa_38 = DFA.unpackEncodedStringToUnsignedChars(dfa_38s); |
| static final char[] dfa_39 = DFA.unpackEncodedStringToUnsignedChars(dfa_39s); |
| static final short[] dfa_40 = DFA.unpackEncodedString(dfa_40s); |
| static final short[] dfa_41 = DFA.unpackEncodedString(dfa_41s); |
| static final short[][] dfa_42 = unpackEncodedStringArray(dfa_42s); |
| |
| class DFA31 extends DFA { |
| |
| public DFA31(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 31; |
| this.eot = dfa_25; |
| this.eof = dfa_25; |
| this.min = dfa_38; |
| this.max = dfa_39; |
| this.accept = dfa_40; |
| this.special = dfa_41; |
| this.transition = dfa_42; |
| } |
| public String getDescription() { |
| return "2106:1: rule__LiteralObjectReference__Alternatives_1 : ( ( ( rule__LiteralObjectReference__ObjectAssignment_1_0 ) ) | ( ( rule__LiteralObjectReference__SymbolAssignment_1_1 ) ) );"; |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA31_3 = input.LA(1); |
| |
| |
| int index31_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred53_InternalSEW()) ) {s = 10;} |
| |
| else if ( (true) ) {s = 11;} |
| |
| |
| input.seek(index31_3); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA31_7 = input.LA(1); |
| |
| |
| int index31_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred53_InternalSEW()) ) {s = 10;} |
| |
| else if ( (true) ) {s = 11;} |
| |
| |
| input.seek(index31_7); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA31_1 = input.LA(1); |
| |
| |
| int index31_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred53_InternalSEW()) ) {s = 10;} |
| |
| else if ( (true) ) {s = 11;} |
| |
| |
| input.seek(index31_1); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA31_4 = input.LA(1); |
| |
| |
| int index31_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred53_InternalSEW()) ) {s = 10;} |
| |
| else if ( (true) ) {s = 11;} |
| |
| |
| input.seek(index31_4); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA31_2 = input.LA(1); |
| |
| |
| int index31_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred53_InternalSEW()) ) {s = 10;} |
| |
| else if ( (true) ) {s = 11;} |
| |
| |
| input.seek(index31_2); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA31_5 = input.LA(1); |
| |
| |
| int index31_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred53_InternalSEW()) ) {s = 10;} |
| |
| else if ( (true) ) {s = 11;} |
| |
| |
| input.seek(index31_5); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA31_6 = input.LA(1); |
| |
| |
| int index31_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred53_InternalSEW()) ) {s = 10;} |
| |
| else if ( (true) ) {s = 11;} |
| |
| |
| input.seek(index31_6); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA31_8 = input.LA(1); |
| |
| |
| int index31_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred53_InternalSEW()) ) {s = 10;} |
| |
| else if ( (true) ) {s = 11;} |
| |
| |
| input.seek(index31_8); |
| if ( s>=0 ) return s; |
| break; |
| case 8 : |
| int LA31_9 = input.LA(1); |
| |
| |
| int index31_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred53_InternalSEW()) ) {s = 10;} |
| |
| else if ( (true) ) {s = 11;} |
| |
| |
| input.seek(index31_9); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 31, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String[] dfa_43s = { |
| "\1\11\1\12\6\uffff\1\2\3\uffff\1\3\27\uffff\1\4\1\5\1\6\1\7\1\1\1\10", |
| "\2\13\7\uffff\1\13\3\uffff\1\13\27\uffff\6\13\7\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "\1\13\61\uffff\1\13\1\uffff\1\13\1\12", |
| "", |
| "" |
| }; |
| static final short[][] dfa_43 = unpackEncodedStringArray(dfa_43s); |
| |
| class DFA38 extends DFA { |
| |
| public DFA38(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 38; |
| this.eot = dfa_25; |
| this.eof = dfa_25; |
| this.min = dfa_26; |
| this.max = dfa_27; |
| this.accept = dfa_28; |
| this.special = dfa_29; |
| this.transition = dfa_43; |
| } |
| public String getDescription() { |
| return "2301:1: rule__DeprecatedProperty__Alternatives : ( ( ruleDeprecatedSection ) | ( ruleDeprecatedAttribute ) );"; |
| } |
| } |
| static final String dfa_44s = "\67\uffff"; |
| static final String dfa_45s = "\1\6\11\5\2\uffff\22\5\2\6\1\62\1\uffff\2\6\1\62\22\5"; |
| static final String dfa_46s = "\1\57\11\72\2\uffff\22\106\2\57\1\106\1\uffff\2\57\23\106"; |
| static final String dfa_47s = "\12\uffff\1\1\1\3\25\uffff\1\2\25\uffff"; |
| static final String dfa_48s = "\67\uffff}>"; |
| static final String[] dfa_49s = { |
| "\1\11\1\12\6\uffff\1\1\3\uffff\1\2\27\uffff\1\3\1\4\1\5\1\6\1\7\1\10", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\1\13\1\24\7\uffff\1\14\3\uffff\1\15\4\13\23\uffff\1\16\1\17\1\20\1\21\1\22\1\23\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\1\13\1\35\7\uffff\1\25\3\uffff\1\26\4\13\23\uffff\1\27\1\30\1\31\1\32\1\33\1\34\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "\2\13\7\uffff\1\13\3\uffff\5\13\23\uffff\6\13\2\uffff\1\13\7\uffff\1\12", |
| "", |
| "", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\55\7\uffff\1\45\3\uffff\1\46\27\uffff\1\47\1\50\1\51\1\52\1\53\1\54", |
| "\1\55\7\uffff\1\45\3\uffff\1\46\27\uffff\1\47\1\50\1\51\1\52\1\53\1\54", |
| "\1\13\23\uffff\1\41", |
| "", |
| "\1\66\7\uffff\1\56\3\uffff\1\57\27\uffff\1\60\1\61\1\62\1\63\1\64\1\65", |
| "\1\66\7\uffff\1\56\3\uffff\1\57\27\uffff\1\60\1\61\1\62\1\63\1\64\1\65", |
| "\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\40\15\uffff\1\36\1\37\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41", |
| "\1\44\15\uffff\1\42\1\43\35\uffff\1\13\23\uffff\1\41" |
| }; |
| |
| static final short[] dfa_44 = DFA.unpackEncodedString(dfa_44s); |
| static final char[] dfa_45 = DFA.unpackEncodedStringToUnsignedChars(dfa_45s); |
| static final char[] dfa_46 = DFA.unpackEncodedStringToUnsignedChars(dfa_46s); |
| static final short[] dfa_47 = DFA.unpackEncodedString(dfa_47s); |
| static final short[] dfa_48 = DFA.unpackEncodedString(dfa_48s); |
| static final short[][] dfa_49 = unpackEncodedStringArray(dfa_49s); |
| |
| class DFA40 extends DFA { |
| |
| public DFA40(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 40; |
| this.eot = dfa_44; |
| this.eof = dfa_44; |
| this.min = dfa_45; |
| this.max = dfa_46; |
| this.accept = dfa_47; |
| this.special = dfa_48; |
| this.transition = dfa_49; |
| } |
| public String getDescription() { |
| return "2343:1: rule__DeprecatedSection__ElementAlternatives_0_3_0 : ( ( ruleDeprecatedAttribute ) | ( ruleDeprecatedObject ) | ( ruleObject ) );"; |
| } |
| } |
| |
| class DFA42 extends DFA { |
| |
| public DFA42(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 42; |
| this.eot = dfa_44; |
| this.eof = dfa_44; |
| this.min = dfa_45; |
| this.max = dfa_46; |
| this.accept = dfa_47; |
| this.special = dfa_48; |
| this.transition = dfa_49; |
| } |
| public String getDescription() { |
| return "2391:1: rule__DeprecatedSection__ElementAlternatives_1_2_0_1_0 : ( ( ruleDeprecatedAttribute ) | ( ruleDeprecatedObject ) | ( ruleObject ) );"; |
| } |
| } |
| |
| class DFA43 extends DFA { |
| |
| public DFA43(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 43; |
| this.eot = dfa_44; |
| this.eof = dfa_44; |
| this.min = dfa_45; |
| this.max = dfa_46; |
| this.accept = dfa_47; |
| this.special = dfa_48; |
| this.transition = dfa_49; |
| } |
| public String getDescription() { |
| return "2418:1: rule__DeprecatedSection__ElementAlternatives_1_2_1_1_0 : ( ( ruleDeprecatedAttribute ) | ( ruleDeprecatedObject ) | ( ruleObject ) );"; |
| } |
| } |
| static final String dfa_50s = "\1\1\14\uffff"; |
| static final String dfa_51s = "\1\6\2\uffff\11\0\1\uffff"; |
| static final String dfa_52s = "\1\63\2\uffff\11\0\1\uffff"; |
| static final String dfa_53s = "\1\uffff\1\2\12\uffff\1\1"; |
| static final String dfa_54s = "\3\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\uffff}>"; |
| static final String[] dfa_55s = { |
| "\1\13\7\uffff\1\3\3\uffff\1\4\27\uffff\1\5\1\6\1\7\1\10\1\11\1\12\3\uffff\1\1", |
| "", |
| "", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "" |
| }; |
| static final short[] dfa_50 = DFA.unpackEncodedString(dfa_50s); |
| static final char[] dfa_51 = DFA.unpackEncodedStringToUnsignedChars(dfa_51s); |
| static final char[] dfa_52 = DFA.unpackEncodedStringToUnsignedChars(dfa_52s); |
| static final short[] dfa_53 = DFA.unpackEncodedString(dfa_53s); |
| static final short[] dfa_54 = DFA.unpackEncodedString(dfa_54s); |
| static final short[][] dfa_55 = unpackEncodedStringArray(dfa_55s); |
| |
| class DFA61 extends DFA { |
| |
| public DFA61(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 61; |
| this.eot = dfa_1; |
| this.eof = dfa_50; |
| this.min = dfa_51; |
| this.max = dfa_52; |
| this.accept = dfa_53; |
| this.special = dfa_54; |
| this.transition = dfa_55; |
| } |
| public String getDescription() { |
| return "()* loopback of 3693:2: ( rule__Section__ElementAssignment_2_1_1 )*"; |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA61_3 = input.LA(1); |
| |
| |
| int index61_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred94_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index61_3); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA61_4 = input.LA(1); |
| |
| |
| int index61_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred94_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index61_4); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA61_5 = input.LA(1); |
| |
| |
| int index61_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred94_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index61_5); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA61_6 = input.LA(1); |
| |
| |
| int index61_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred94_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index61_6); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA61_7 = input.LA(1); |
| |
| |
| int index61_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred94_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index61_7); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA61_8 = input.LA(1); |
| |
| |
| int index61_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred94_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index61_8); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA61_9 = input.LA(1); |
| |
| |
| int index61_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred94_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index61_9); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA61_10 = input.LA(1); |
| |
| |
| int index61_10 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred94_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index61_10); |
| if ( s>=0 ) return s; |
| break; |
| case 8 : |
| int LA61_11 = input.LA(1); |
| |
| |
| int index61_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred94_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index61_11); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 61, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String dfa_56s = "\71\uffff"; |
| static final String dfa_57s = "\1\2\70\uffff"; |
| static final String dfa_58s = "\1\4\1\0\67\uffff"; |
| static final String dfa_59s = "\1\120\1\0\67\uffff"; |
| static final String dfa_60s = "\2\uffff\1\2\65\uffff\1\1"; |
| static final String dfa_61s = "\1\uffff\1\0\67\uffff}>"; |
| static final String[] dfa_62s = { |
| "\5\2\5\uffff\1\2\3\uffff\1\2\1\uffff\1\2\2\uffff\31\2\3\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\1\2\1\1\4\uffff\5\2\2\uffff\11\2", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] dfa_56 = DFA.unpackEncodedString(dfa_56s); |
| static final short[] dfa_57 = DFA.unpackEncodedString(dfa_57s); |
| static final char[] dfa_58 = DFA.unpackEncodedStringToUnsignedChars(dfa_58s); |
| static final char[] dfa_59 = DFA.unpackEncodedStringToUnsignedChars(dfa_59s); |
| static final short[] dfa_60 = DFA.unpackEncodedString(dfa_60s); |
| static final short[] dfa_61 = DFA.unpackEncodedString(dfa_61s); |
| static final short[][] dfa_62 = unpackEncodedStringArray(dfa_62s); |
| |
| class DFA70 extends DFA { |
| |
| public DFA70(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 70; |
| this.eot = dfa_56; |
| this.eof = dfa_57; |
| this.min = dfa_58; |
| this.max = dfa_59; |
| this.accept = dfa_60; |
| this.special = dfa_61; |
| this.transition = dfa_62; |
| } |
| public String getDescription() { |
| return "4773:2: ( rule__AdditiveExpression__Group_1__0 )?"; |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA70_1 = input.LA(1); |
| |
| |
| int index70_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred103_InternalSEW()) ) {s = 56;} |
| |
| else if ( (true) ) {s = 2;} |
| |
| |
| input.seek(index70_1); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 70, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String dfa_63s = "\1\1\70\uffff"; |
| static final String dfa_64s = "\1\4\35\uffff\1\0\32\uffff"; |
| static final String dfa_65s = "\1\120\35\uffff\1\0\32\uffff"; |
| static final String dfa_66s = "\1\uffff\1\2\66\uffff\1\1"; |
| static final String dfa_67s = "\36\uffff\1\0\32\uffff}>"; |
| static final String[] dfa_68s = { |
| "\5\1\5\uffff\1\1\3\uffff\1\1\1\uffff\1\1\2\uffff\31\1\3\uffff\1\1\1\uffff\1\1\1\uffff\3\1\1\uffff\1\1\1\36\4\uffff\5\1\2\uffff\11\1", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| static final short[] dfa_63 = DFA.unpackEncodedString(dfa_63s); |
| static final char[] dfa_64 = DFA.unpackEncodedStringToUnsignedChars(dfa_64s); |
| static final char[] dfa_65 = DFA.unpackEncodedStringToUnsignedChars(dfa_65s); |
| static final short[] dfa_66 = DFA.unpackEncodedString(dfa_66s); |
| static final short[] dfa_67 = DFA.unpackEncodedString(dfa_67s); |
| static final short[][] dfa_68 = unpackEncodedStringArray(dfa_68s); |
| |
| class DFA71 extends DFA { |
| |
| public DFA71(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 71; |
| this.eot = dfa_56; |
| this.eof = dfa_63; |
| this.min = dfa_64; |
| this.max = dfa_65; |
| this.accept = dfa_66; |
| this.special = dfa_67; |
| this.transition = dfa_68; |
| } |
| public String getDescription() { |
| return "()* loopback of 4881:2: ( rule__AdditiveExpression__Group_1_3__0 )*"; |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA71_30 = input.LA(1); |
| |
| |
| int index71_30 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred104_InternalSEW()) ) {s = 56;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index71_30); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 71, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String dfa_69s = "\1\2\2\uffff\11\2\1\uffff"; |
| static final String dfa_70s = "\2\4\1\uffff\11\4\1\uffff"; |
| static final String dfa_71s = "\2\120\1\uffff\11\120\1\uffff"; |
| static final String dfa_72s = "\2\uffff\1\2\11\uffff\1\1"; |
| static final String[] dfa_73s = { |
| "\5\2\5\uffff\1\2\3\uffff\1\2\1\uffff\1\2\2\uffff\11\2\1\1\17\2\3\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\13\2\2\uffff\11\2", |
| "\2\2\1\13\1\uffff\1\2\5\uffff\1\3\3\uffff\1\4\1\uffff\1\2\17\uffff\6\2\1\5\1\6\1\7\1\10\1\11\1\12\7\uffff\1\2\4\uffff\1\2\4\uffff\1\2\1\uffff\3\2\4\uffff\7\2", |
| "", |
| "\5\2\5\uffff\1\2\3\uffff\3\2\2\uffff\11\2\2\uffff\1\14\1\uffff\14\2\3\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\13\2\2\uffff\11\2", |
| "\5\2\5\uffff\1\2\3\uffff\3\2\2\uffff\11\2\2\uffff\1\14\1\uffff\14\2\3\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\13\2\2\uffff\11\2", |
| "\5\2\5\uffff\1\2\3\uffff\3\2\2\uffff\11\2\2\uffff\1\14\1\uffff\14\2\3\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\13\2\2\uffff\11\2", |
| "\5\2\5\uffff\1\2\3\uffff\3\2\2\uffff\11\2\2\uffff\1\14\1\uffff\14\2\3\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\13\2\2\uffff\11\2", |
| "\5\2\5\uffff\1\2\3\uffff\3\2\2\uffff\11\2\2\uffff\1\14\1\uffff\14\2\3\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\13\2\2\uffff\11\2", |
| "\5\2\5\uffff\1\2\3\uffff\3\2\2\uffff\11\2\2\uffff\1\14\1\uffff\14\2\3\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\13\2\2\uffff\11\2", |
| "\5\2\5\uffff\1\2\3\uffff\3\2\2\uffff\11\2\2\uffff\1\14\1\uffff\14\2\3\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\13\2\2\uffff\11\2", |
| "\5\2\5\uffff\1\2\3\uffff\3\2\2\uffff\11\2\2\uffff\1\14\1\uffff\14\2\3\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\13\2\2\uffff\11\2", |
| "\5\2\5\uffff\1\2\3\uffff\3\2\2\uffff\11\2\2\uffff\1\14\1\uffff\14\2\3\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\13\2\2\uffff\11\2", |
| "" |
| }; |
| static final short[] dfa_69 = DFA.unpackEncodedString(dfa_69s); |
| static final char[] dfa_70 = DFA.unpackEncodedStringToUnsignedChars(dfa_70s); |
| static final char[] dfa_71 = DFA.unpackEncodedStringToUnsignedChars(dfa_71s); |
| static final short[] dfa_72 = DFA.unpackEncodedString(dfa_72s); |
| static final short[][] dfa_73 = unpackEncodedStringArray(dfa_73s); |
| |
| class DFA80 extends DFA { |
| |
| public DFA80(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 80; |
| this.eot = dfa_1; |
| this.eof = dfa_69; |
| this.min = dfa_70; |
| this.max = dfa_71; |
| this.accept = dfa_72; |
| this.special = dfa_11; |
| this.transition = dfa_73; |
| } |
| public String getDescription() { |
| return "6420:2: ( rule__LiteralNullValue__Group_2__0 )?"; |
| } |
| } |
| static final String dfa_74s = "\1\uffff\1\14\1\uffff\11\14\2\uffff"; |
| static final String dfa_75s = "\1\6\1\5\1\uffff\11\5\1\uffff\1\62"; |
| static final String dfa_76s = "\1\57\1\72\1\uffff\11\72\1\uffff\1\71"; |
| static final String dfa_77s = "\2\uffff\1\1\11\uffff\1\2\1\uffff"; |
| static final String dfa_78s = "\16\uffff}>"; |
| static final String[] dfa_79s = { |
| "\2\2\6\uffff\1\2\3\uffff\1\2\27\uffff\5\2\1\1", |
| "\1\2\1\13\1\14\6\uffff\1\3\3\uffff\1\4\4\2\23\uffff\1\5\1\6\1\7\1\10\1\11\1\12\2\uffff\1\2\7\uffff\1\2", |
| "", |
| "\1\15\2\14\6\uffff\1\14\3\uffff\1\14\2\2\25\uffff\6\14\2\uffff\1\2\4\uffff\1\14\1\uffff\2\14", |
| "\1\15\2\14\6\uffff\1\14\3\uffff\1\14\2\2\25\uffff\6\14\2\uffff\1\2\4\uffff\1\14\1\uffff\2\14", |
| "\1\15\2\14\6\uffff\1\14\3\uffff\1\14\2\2\25\uffff\6\14\2\uffff\1\2\4\uffff\1\14\1\uffff\2\14", |
| "\1\15\2\14\6\uffff\1\14\3\uffff\1\14\2\2\25\uffff\6\14\2\uffff\1\2\4\uffff\4\14", |
| "\1\15\2\14\6\uffff\1\14\3\uffff\1\14\2\2\25\uffff\6\14\2\uffff\1\2\4\uffff\1\14\1\uffff\2\14", |
| "\1\15\2\14\6\uffff\1\14\3\uffff\1\14\2\2\25\uffff\6\14\2\uffff\1\2\4\uffff\4\14", |
| "\1\15\2\14\6\uffff\1\14\3\uffff\1\14\2\2\25\uffff\6\14\2\uffff\1\2\4\uffff\1\14\1\uffff\2\14", |
| "\1\15\2\14\6\uffff\1\14\3\uffff\1\14\2\2\25\uffff\6\14\2\uffff\1\2\4\uffff\1\14\1\uffff\2\14", |
| "\1\15\2\14\6\uffff\1\14\3\uffff\1\14\2\2\25\uffff\6\14\2\uffff\1\2\4\uffff\1\14\1\uffff\2\14", |
| "", |
| "\1\2\4\uffff\1\14\1\uffff\1\14" |
| }; |
| static final short[] dfa_74 = DFA.unpackEncodedString(dfa_74s); |
| static final char[] dfa_75 = DFA.unpackEncodedStringToUnsignedChars(dfa_75s); |
| static final char[] dfa_76 = DFA.unpackEncodedStringToUnsignedChars(dfa_76s); |
| static final short[] dfa_77 = DFA.unpackEncodedString(dfa_77s); |
| static final short[] dfa_78 = DFA.unpackEncodedString(dfa_78s); |
| static final short[][] dfa_79 = unpackEncodedStringArray(dfa_79s); |
| |
| class DFA91 extends DFA { |
| |
| public DFA91(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 91; |
| this.eot = dfa_32; |
| this.eof = dfa_74; |
| this.min = dfa_75; |
| this.max = dfa_76; |
| this.accept = dfa_77; |
| this.special = dfa_78; |
| this.transition = dfa_79; |
| } |
| public String getDescription() { |
| return "()* loopback of 7825:2: ( rule__DeprecatedSection__ElementAssignment_0_3 )*"; |
| } |
| } |
| static final String dfa_80s = "\1\12\14\uffff"; |
| static final String dfa_81s = "\1\6\11\0\3\uffff"; |
| static final String dfa_82s = "\1\57\11\0\3\uffff"; |
| static final String dfa_83s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\3\uffff}>"; |
| static final String[] dfa_84s = { |
| "\1\11\1\12\6\uffff\1\1\3\uffff\1\2\27\uffff\1\3\1\4\1\5\1\6\1\7\1\10", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "" |
| }; |
| static final short[] dfa_80 = DFA.unpackEncodedString(dfa_80s); |
| static final char[] dfa_81 = DFA.unpackEncodedStringToUnsignedChars(dfa_81s); |
| static final char[] dfa_82 = DFA.unpackEncodedStringToUnsignedChars(dfa_82s); |
| static final short[] dfa_83 = DFA.unpackEncodedString(dfa_83s); |
| static final short[][] dfa_84 = unpackEncodedStringArray(dfa_84s); |
| |
| class DFA92 extends DFA { |
| |
| public DFA92(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 92; |
| this.eot = dfa_1; |
| this.eof = dfa_80; |
| this.min = dfa_81; |
| this.max = dfa_82; |
| this.accept = dfa_23; |
| this.special = dfa_83; |
| this.transition = dfa_84; |
| } |
| public String getDescription() { |
| return "7878:2: ( ruleXID )?"; |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA92_1 = input.LA(1); |
| |
| |
| int index92_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index92_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA92_2 = input.LA(1); |
| |
| |
| int index92_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index92_2); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA92_3 = input.LA(1); |
| |
| |
| int index92_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index92_3); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA92_4 = input.LA(1); |
| |
| |
| int index92_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index92_4); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA92_5 = input.LA(1); |
| |
| |
| int index92_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index92_5); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA92_6 = input.LA(1); |
| |
| |
| int index92_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index92_6); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA92_7 = input.LA(1); |
| |
| |
| int index92_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index92_7); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA92_8 = input.LA(1); |
| |
| |
| int index92_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index92_8); |
| if ( s>=0 ) return s; |
| break; |
| case 8 : |
| int LA92_9 = input.LA(1); |
| |
| |
| int index92_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index92_9); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 92, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String dfa_85s = "\1\6\1\uffff\12\0\1\uffff"; |
| static final String dfa_86s = "\1\57\1\uffff\12\0\1\uffff"; |
| static final String dfa_87s = "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\uffff}>"; |
| static final String[] dfa_88s = { |
| "\1\12\1\13\6\uffff\1\4\3\uffff\1\5\27\uffff\1\6\1\2\1\7\1\10\1\3\1\11", |
| "", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "" |
| }; |
| static final char[] dfa_85 = DFA.unpackEncodedStringToUnsignedChars(dfa_85s); |
| static final char[] dfa_86 = DFA.unpackEncodedStringToUnsignedChars(dfa_86s); |
| static final short[] dfa_87 = DFA.unpackEncodedString(dfa_87s); |
| static final short[][] dfa_88 = unpackEncodedStringArray(dfa_88s); |
| |
| class DFA95 extends DFA { |
| |
| public DFA95(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 95; |
| this.eot = dfa_1; |
| this.eof = dfa_50; |
| this.min = dfa_85; |
| this.max = dfa_86; |
| this.accept = dfa_53; |
| this.special = dfa_87; |
| this.transition = dfa_88; |
| } |
| public String getDescription() { |
| return "()* loopback of 8094:2: ( rule__DeprecatedSection__ElementAssignment_1_2_1_1 )*"; |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA95_2 = input.LA(1); |
| |
| |
| int index95_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred128_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index95_2); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA95_3 = input.LA(1); |
| |
| |
| int index95_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred128_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index95_3); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA95_4 = input.LA(1); |
| |
| |
| int index95_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred128_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index95_4); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA95_5 = input.LA(1); |
| |
| |
| int index95_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred128_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index95_5); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA95_6 = input.LA(1); |
| |
| |
| int index95_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred128_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index95_6); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA95_7 = input.LA(1); |
| |
| |
| int index95_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred128_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index95_7); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA95_8 = input.LA(1); |
| |
| |
| int index95_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred128_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index95_8); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA95_9 = input.LA(1); |
| |
| |
| int index95_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred128_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index95_9); |
| if ( s>=0 ) return s; |
| break; |
| case 8 : |
| int LA95_10 = input.LA(1); |
| |
| |
| int index95_10 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred128_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index95_10); |
| if ( s>=0 ) return s; |
| break; |
| case 9 : |
| int LA95_11 = input.LA(1); |
| |
| |
| int index95_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred128_InternalSEW()) ) {s = 12;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index95_11); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 95, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| |
| |
| |
| private static class FollowSets000 { |
| 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[]{0x0000FC0000044042L}); |
| public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000FC000007C040L}); |
| public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0004FC0000044060L}); |
| public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0008FC0000044040L}); |
| public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000100000000L}); |
| public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000044000L}); |
| public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0030FC0000044060L}); |
| public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0040000000100100L,0x0000000000000020L}); |
| public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000180000L}); |
| public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000180002L}); |
| public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000FC0000044040L}); |
| public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000600000L}); |
| public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0004FC0000044040L}); |
| public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000000020L}); |
| public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0280000000000020L}); |
| public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0100FC0000044040L}); |
| public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0400000000000000L}); |
| public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x10C0FFF000144170L,0x000000000001FD3AL}); |
| public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0800000000000000L}); |
| public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); |
| public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0200000000000000L}); |
| public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000001800000L}); |
| public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x10C0FFF000144170L,0x000000000001FC3AL}); |
| public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000001800002L}); |
| public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000006000000L}); |
| public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000006000002L}); |
| public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x00000000F8000000L}); |
| public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000F00000000L}); |
| public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x1000000000000000L}); |
| public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x1000000000000002L}); |
| public static final BitSet FOLLOW_33 = new BitSet(new long[]{0xE000000000000000L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x2000000000000000L}); |
| public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x2000000000000002L}); |
| public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x4000000000000000L}); |
| public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x4000000000000002L}); |
| public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x8000000000000000L}); |
| public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x8000000000000002L}); |
| public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L}); |
| public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000003000000000L}); |
| public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); |
| public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0080000000000000L}); |
| public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x11C0FFF000144170L,0x000000000001FD3AL}); |
| public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0020000000000000L}); |
| public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0020000000000002L}); |
| public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000FC0000044040L,0x0000000000000008L}); |
| public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000100L,0x0000000000000020L}); |
| public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); |
| public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000400000000L}); |
| public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); |
| public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000C00L}); |
| public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); |
| public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); |
| public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
| public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000100L}); |
| public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000100000L}); |
| public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000040000000000L}); |
| public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000020L,0x0000000000000040L}); |
| public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L}); |
| public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000FC00000440C0L}); |
| public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000FC00000440C2L}); |
| public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000400000000000L}); |
| public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000FC000007C0C0L}); |
| public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000FC000007C0C2L}); |
| public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0100FC000007C0C0L}); |
| public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0003000000000000L}); |
| public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x10C8FFF000144170L,0x000000000001FD3AL}); |
| public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x10C0FFF000144172L,0x000000000001FD3AL}); |
| } |
| |
| |
| } |
