| package org.eclipse.ocl.xtext.essentialocl.ui.contentassist.antlr.internal; |
| |
| import java.io.InputStream; |
| import org.eclipse.xtext.*; |
| import org.eclipse.xtext.parser.*; |
| import org.eclipse.xtext.parser.impl.*; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.xtext.parser.antlr.XtextTokenStream; |
| import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; |
| import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; |
| import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA; |
| import org.eclipse.ocl.xtext.essentialocl.services.EssentialOCLGrammarAccess; |
| |
| |
| |
| 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) 2011, 2021 Willink Transformations and others. |
| * 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: |
| * E.D.Willink - initial API and implementation |
| *******************************************************************************/ |
| @SuppressWarnings("all") |
| public class InternalEssentialOCLParser extends AbstractInternalContentAssistParser { |
| public static final String[] tokenNames = new String[] { |
| "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_INT", "RULE_SINGLE_QUOTED_STRING", "RULE_SIMPLE_ID", "RULE_ESCAPED_ID", "RULE_ESCAPED_CHARACTER", "RULE_LETTER_CHARACTER", "RULE_DOUBLE_QUOTED_STRING", "RULE_ML_SINGLE_QUOTED_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'-'", "'not'", "'not2'", "'*'", "'/'", "'+'", "'>'", "'<'", "'>='", "'<='", "'='", "'<>'", "'and'", "'and2'", "'implies'", "'implies2'", "'or'", "'or2'", "'xor'", "'xor2'", "'.'", "'->'", "'?.'", "'?->'", "'Map'", "'Tuple'", "'Boolean'", "'Integer'", "'Real'", "'String'", "'UnlimitedNatural'", "'OclAny'", "'OclInvalid'", "'OclVoid'", "'Set'", "'Bag'", "'Sequence'", "'Collection'", "'OrderedSet'", "'with'", "'<-'", "'|?'", "'?'", "'('", "')'", "','", "':'", "'{'", "'}'", "'..'", "'++'", "'Lambda'", "'invalid'", "'null'", "'pre'", "'['", "']'", "'in'", "'if'", "'then'", "'else'", "'endif'", "'elseif'", "'let'", "'self'", "'::'", "'extends'", "'&&'", "'true'", "'false'", "'@'", "'|'", "';'", "'|1'" |
| }; |
| public static final int T__50=50; |
| public static final int RULE_LETTER_CHARACTER=9; |
| public static final int T__19=19; |
| 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 RULE_ESCAPED_CHARACTER=8; |
| public static final int T__56=56; |
| public static final int T__57=57; |
| public static final int T__58=58; |
| public static final int T__51=51; |
| public static final int RULE_ML_SINGLE_QUOTED_STRING=11; |
| 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 T__26=26; |
| public static final int T__27=27; |
| public static final int T__28=28; |
| public static final int RULE_INT=4; |
| 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=12; |
| 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_SL_COMMENT=13; |
| 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 T__81=81; |
| public static final int T__82=82; |
| public static final int RULE_SIMPLE_ID=6; |
| public static final int T__83=83; |
| public static final int RULE_WS=14; |
| public static final int RULE_ANY_OTHER=15; |
| public static final int RULE_SINGLE_QUOTED_STRING=5; |
| public static final int T__48=48; |
| public static final int T__49=49; |
| public static final int RULE_DOUBLE_QUOTED_STRING=10; |
| public static final int T__44=44; |
| public static final int T__88=88; |
| public static final int T__45=45; |
| public static final int T__89=89; |
| public static final int T__46=46; |
| public static final int T__47=47; |
| public static final int RULE_ESCAPED_ID=7; |
| public static final int T__40=40; |
| public static final int T__84=84; |
| public static final int T__41=41; |
| public static final int T__85=85; |
| public static final int T__42=42; |
| public static final int T__86=86; |
| public static final int T__43=43; |
| public static final int T__87=87; |
| |
| // delegates |
| // delegators |
| |
| |
| public InternalEssentialOCLParser(TokenStream input) { |
| this(input, new RecognizerSharedState()); |
| } |
| public InternalEssentialOCLParser(TokenStream input, RecognizerSharedState state) { |
| super(input, state); |
| |
| } |
| |
| |
| public String[] getTokenNames() { return InternalEssentialOCLParser.tokenNames; } |
| public String getGrammarFileName() { return "InternalEssentialOCL.g"; } |
| |
| |
| |
| private EssentialOCLGrammarAccess grammarAccess; |
| |
| public void setGrammarAccess(EssentialOCLGrammarAccess grammarAccess) { |
| this.grammarAccess = grammarAccess; |
| } |
| |
| @Override |
| protected Grammar getGrammar() { |
| return grammarAccess.getGrammar(); |
| } |
| |
| @Override |
| protected String getValueForTokenName(String tokenName) { |
| return tokenName; |
| } |
| |
| |
| |
| |
| // $ANTLR start "entryRuleModel" |
| // InternalEssentialOCL.g:68:1: entryRuleModel : ruleModel EOF ; |
| public final void entryRuleModel() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:69:1: ( ruleModel EOF ) |
| // InternalEssentialOCL.g:70:1: ruleModel EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getModelRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleModel(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getModelRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleModel" |
| |
| |
| // $ANTLR start "ruleModel" |
| // InternalEssentialOCL.g:77:1: ruleModel : ( ( rule__Model__OwnedExpressionAssignment ) ) ; |
| public final void ruleModel() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:81:2: ( ( ( rule__Model__OwnedExpressionAssignment ) ) ) |
| // InternalEssentialOCL.g:82:1: ( ( rule__Model__OwnedExpressionAssignment ) ) |
| { |
| // InternalEssentialOCL.g:82:1: ( ( rule__Model__OwnedExpressionAssignment ) ) |
| // InternalEssentialOCL.g:83:1: ( rule__Model__OwnedExpressionAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getModelAccess().getOwnedExpressionAssignment()); |
| } |
| // InternalEssentialOCL.g:84:1: ( rule__Model__OwnedExpressionAssignment ) |
| // InternalEssentialOCL.g:84:2: rule__Model__OwnedExpressionAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__Model__OwnedExpressionAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getModelAccess().getOwnedExpressionAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleModel" |
| |
| |
| // $ANTLR start "entryRuleEssentialOCLUnaryOperatorName" |
| // InternalEssentialOCL.g:98:1: entryRuleEssentialOCLUnaryOperatorName : ruleEssentialOCLUnaryOperatorName EOF ; |
| public final void entryRuleEssentialOCLUnaryOperatorName() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:99:1: ( ruleEssentialOCLUnaryOperatorName EOF ) |
| // InternalEssentialOCL.g:100:1: ruleEssentialOCLUnaryOperatorName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnaryOperatorNameRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleEssentialOCLUnaryOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnaryOperatorNameRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEssentialOCLUnaryOperatorName" |
| |
| |
| // $ANTLR start "ruleEssentialOCLUnaryOperatorName" |
| // InternalEssentialOCL.g:107:1: ruleEssentialOCLUnaryOperatorName : ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) ) ; |
| public final void ruleEssentialOCLUnaryOperatorName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:111:2: ( ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) ) ) |
| // InternalEssentialOCL.g:112:1: ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:112:1: ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) ) |
| // InternalEssentialOCL.g:113:1: ( rule__EssentialOCLUnaryOperatorName__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:114:1: ( rule__EssentialOCLUnaryOperatorName__Alternatives ) |
| // InternalEssentialOCL.g:114:2: rule__EssentialOCLUnaryOperatorName__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EssentialOCLUnaryOperatorName__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEssentialOCLUnaryOperatorName" |
| |
| |
| // $ANTLR start "entryRuleEssentialOCLInfixOperatorName" |
| // InternalEssentialOCL.g:126:1: entryRuleEssentialOCLInfixOperatorName : ruleEssentialOCLInfixOperatorName EOF ; |
| public final void entryRuleEssentialOCLInfixOperatorName() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:127:1: ( ruleEssentialOCLInfixOperatorName EOF ) |
| // InternalEssentialOCL.g:128:1: ruleEssentialOCLInfixOperatorName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleEssentialOCLInfixOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEssentialOCLInfixOperatorName" |
| |
| |
| // $ANTLR start "ruleEssentialOCLInfixOperatorName" |
| // InternalEssentialOCL.g:135:1: ruleEssentialOCLInfixOperatorName : ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) ) ; |
| public final void ruleEssentialOCLInfixOperatorName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:139:2: ( ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) ) ) |
| // InternalEssentialOCL.g:140:1: ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:140:1: ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) ) |
| // InternalEssentialOCL.g:141:1: ( rule__EssentialOCLInfixOperatorName__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:142:1: ( rule__EssentialOCLInfixOperatorName__Alternatives ) |
| // InternalEssentialOCL.g:142:2: rule__EssentialOCLInfixOperatorName__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EssentialOCLInfixOperatorName__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEssentialOCLInfixOperatorName" |
| |
| |
| // $ANTLR start "entryRuleEssentialOCLNavigationOperatorName" |
| // InternalEssentialOCL.g:154:1: entryRuleEssentialOCLNavigationOperatorName : ruleEssentialOCLNavigationOperatorName EOF ; |
| public final void entryRuleEssentialOCLNavigationOperatorName() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:155:1: ( ruleEssentialOCLNavigationOperatorName EOF ) |
| // InternalEssentialOCL.g:156:1: ruleEssentialOCLNavigationOperatorName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLNavigationOperatorNameRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleEssentialOCLNavigationOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLNavigationOperatorNameRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEssentialOCLNavigationOperatorName" |
| |
| |
| // $ANTLR start "ruleEssentialOCLNavigationOperatorName" |
| // InternalEssentialOCL.g:163:1: ruleEssentialOCLNavigationOperatorName : ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) ) ; |
| public final void ruleEssentialOCLNavigationOperatorName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:167:2: ( ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) ) ) |
| // InternalEssentialOCL.g:168:1: ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:168:1: ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) ) |
| // InternalEssentialOCL.g:169:1: ( rule__EssentialOCLNavigationOperatorName__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:170:1: ( rule__EssentialOCLNavigationOperatorName__Alternatives ) |
| // InternalEssentialOCL.g:170:2: rule__EssentialOCLNavigationOperatorName__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EssentialOCLNavigationOperatorName__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEssentialOCLNavigationOperatorName" |
| |
| |
| // $ANTLR start "entryRuleBinaryOperatorName" |
| // InternalEssentialOCL.g:182:1: entryRuleBinaryOperatorName : ruleBinaryOperatorName EOF ; |
| public final void entryRuleBinaryOperatorName() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:183:1: ( ruleBinaryOperatorName EOF ) |
| // InternalEssentialOCL.g:184:1: ruleBinaryOperatorName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBinaryOperatorNameRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleBinaryOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBinaryOperatorNameRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleBinaryOperatorName" |
| |
| |
| // $ANTLR start "ruleBinaryOperatorName" |
| // InternalEssentialOCL.g:191:1: ruleBinaryOperatorName : ( ( rule__BinaryOperatorName__Alternatives ) ) ; |
| public final void ruleBinaryOperatorName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:195:2: ( ( ( rule__BinaryOperatorName__Alternatives ) ) ) |
| // InternalEssentialOCL.g:196:1: ( ( rule__BinaryOperatorName__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:196:1: ( ( rule__BinaryOperatorName__Alternatives ) ) |
| // InternalEssentialOCL.g:197:1: ( rule__BinaryOperatorName__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBinaryOperatorNameAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:198:1: ( rule__BinaryOperatorName__Alternatives ) |
| // InternalEssentialOCL.g:198:2: rule__BinaryOperatorName__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__BinaryOperatorName__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBinaryOperatorNameAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleBinaryOperatorName" |
| |
| |
| // $ANTLR start "entryRuleInfixOperatorName" |
| // InternalEssentialOCL.g:210:1: entryRuleInfixOperatorName : ruleInfixOperatorName EOF ; |
| public final void entryRuleInfixOperatorName() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:211:1: ( ruleInfixOperatorName EOF ) |
| // InternalEssentialOCL.g:212:1: ruleInfixOperatorName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInfixOperatorNameRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleInfixOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInfixOperatorNameRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleInfixOperatorName" |
| |
| |
| // $ANTLR start "ruleInfixOperatorName" |
| // InternalEssentialOCL.g:219:1: ruleInfixOperatorName : ( ruleEssentialOCLInfixOperatorName ) ; |
| public final void ruleInfixOperatorName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:223:2: ( ( ruleEssentialOCLInfixOperatorName ) ) |
| // InternalEssentialOCL.g:224:1: ( ruleEssentialOCLInfixOperatorName ) |
| { |
| // InternalEssentialOCL.g:224:1: ( ruleEssentialOCLInfixOperatorName ) |
| // InternalEssentialOCL.g:225:1: ruleEssentialOCLInfixOperatorName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInfixOperatorNameAccess().getEssentialOCLInfixOperatorNameParserRuleCall()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEssentialOCLInfixOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInfixOperatorNameAccess().getEssentialOCLInfixOperatorNameParserRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleInfixOperatorName" |
| |
| |
| // $ANTLR start "entryRuleNavigationOperatorName" |
| // InternalEssentialOCL.g:238:1: entryRuleNavigationOperatorName : ruleNavigationOperatorName EOF ; |
| public final void entryRuleNavigationOperatorName() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:239:1: ( ruleNavigationOperatorName EOF ) |
| // InternalEssentialOCL.g:240:1: ruleNavigationOperatorName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigationOperatorNameRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNavigationOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigationOperatorNameRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNavigationOperatorName" |
| |
| |
| // $ANTLR start "ruleNavigationOperatorName" |
| // InternalEssentialOCL.g:247:1: ruleNavigationOperatorName : ( ruleEssentialOCLNavigationOperatorName ) ; |
| public final void ruleNavigationOperatorName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:251:2: ( ( ruleEssentialOCLNavigationOperatorName ) ) |
| // InternalEssentialOCL.g:252:1: ( ruleEssentialOCLNavigationOperatorName ) |
| { |
| // InternalEssentialOCL.g:252:1: ( ruleEssentialOCLNavigationOperatorName ) |
| // InternalEssentialOCL.g:253:1: ruleEssentialOCLNavigationOperatorName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigationOperatorNameAccess().getEssentialOCLNavigationOperatorNameParserRuleCall()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEssentialOCLNavigationOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigationOperatorNameAccess().getEssentialOCLNavigationOperatorNameParserRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNavigationOperatorName" |
| |
| |
| // $ANTLR start "entryRuleUnaryOperatorName" |
| // InternalEssentialOCL.g:266:1: entryRuleUnaryOperatorName : ruleUnaryOperatorName EOF ; |
| public final void entryRuleUnaryOperatorName() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:267:1: ( ruleUnaryOperatorName EOF ) |
| // InternalEssentialOCL.g:268:1: ruleUnaryOperatorName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUnaryOperatorNameRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleUnaryOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUnaryOperatorNameRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleUnaryOperatorName" |
| |
| |
| // $ANTLR start "ruleUnaryOperatorName" |
| // InternalEssentialOCL.g:275:1: ruleUnaryOperatorName : ( ruleEssentialOCLUnaryOperatorName ) ; |
| public final void ruleUnaryOperatorName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:279:2: ( ( ruleEssentialOCLUnaryOperatorName ) ) |
| // InternalEssentialOCL.g:280:1: ( ruleEssentialOCLUnaryOperatorName ) |
| { |
| // InternalEssentialOCL.g:280:1: ( ruleEssentialOCLUnaryOperatorName ) |
| // InternalEssentialOCL.g:281:1: ruleEssentialOCLUnaryOperatorName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUnaryOperatorNameAccess().getEssentialOCLUnaryOperatorNameParserRuleCall()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEssentialOCLUnaryOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUnaryOperatorNameAccess().getEssentialOCLUnaryOperatorNameParserRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleUnaryOperatorName" |
| |
| |
| // $ANTLR start "entryRuleEssentialOCLUnrestrictedName" |
| // InternalEssentialOCL.g:294:1: entryRuleEssentialOCLUnrestrictedName : ruleEssentialOCLUnrestrictedName EOF ; |
| public final void entryRuleEssentialOCLUnrestrictedName() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:295:1: ( ruleEssentialOCLUnrestrictedName EOF ) |
| // InternalEssentialOCL.g:296:1: ruleEssentialOCLUnrestrictedName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnrestrictedNameRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleEssentialOCLUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnrestrictedNameRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEssentialOCLUnrestrictedName" |
| |
| |
| // $ANTLR start "ruleEssentialOCLUnrestrictedName" |
| // InternalEssentialOCL.g:303:1: ruleEssentialOCLUnrestrictedName : ( ruleIdentifier ) ; |
| public final void ruleEssentialOCLUnrestrictedName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:307:2: ( ( ruleIdentifier ) ) |
| // InternalEssentialOCL.g:308:1: ( ruleIdentifier ) |
| { |
| // InternalEssentialOCL.g:308:1: ( ruleIdentifier ) |
| // InternalEssentialOCL.g:309:1: ruleIdentifier |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnrestrictedNameAccess().getIdentifierParserRuleCall()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleIdentifier(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnrestrictedNameAccess().getIdentifierParserRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEssentialOCLUnrestrictedName" |
| |
| |
| // $ANTLR start "entryRuleUnrestrictedName" |
| // InternalEssentialOCL.g:322:1: entryRuleUnrestrictedName : ruleUnrestrictedName EOF ; |
| public final void entryRuleUnrestrictedName() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:323:1: ( ruleUnrestrictedName EOF ) |
| // InternalEssentialOCL.g:324:1: ruleUnrestrictedName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUnrestrictedNameRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUnrestrictedNameRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleUnrestrictedName" |
| |
| |
| // $ANTLR start "ruleUnrestrictedName" |
| // InternalEssentialOCL.g:331:1: ruleUnrestrictedName : ( ruleEssentialOCLUnrestrictedName ) ; |
| public final void ruleUnrestrictedName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:335:2: ( ( ruleEssentialOCLUnrestrictedName ) ) |
| // InternalEssentialOCL.g:336:1: ( ruleEssentialOCLUnrestrictedName ) |
| { |
| // InternalEssentialOCL.g:336:1: ( ruleEssentialOCLUnrestrictedName ) |
| // InternalEssentialOCL.g:337:1: ruleEssentialOCLUnrestrictedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUnrestrictedNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEssentialOCLUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUnrestrictedNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleUnrestrictedName" |
| |
| |
| // $ANTLR start "entryRuleEssentialOCLUnreservedName" |
| // InternalEssentialOCL.g:350:1: entryRuleEssentialOCLUnreservedName : ruleEssentialOCLUnreservedName EOF ; |
| public final void entryRuleEssentialOCLUnreservedName() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:351:1: ( ruleEssentialOCLUnreservedName EOF ) |
| // InternalEssentialOCL.g:352:1: ruleEssentialOCLUnreservedName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnreservedNameRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleEssentialOCLUnreservedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnreservedNameRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEssentialOCLUnreservedName" |
| |
| |
| // $ANTLR start "ruleEssentialOCLUnreservedName" |
| // InternalEssentialOCL.g:359:1: ruleEssentialOCLUnreservedName : ( ( rule__EssentialOCLUnreservedName__Alternatives ) ) ; |
| public final void ruleEssentialOCLUnreservedName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:363:2: ( ( ( rule__EssentialOCLUnreservedName__Alternatives ) ) ) |
| // InternalEssentialOCL.g:364:1: ( ( rule__EssentialOCLUnreservedName__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:364:1: ( ( rule__EssentialOCLUnreservedName__Alternatives ) ) |
| // InternalEssentialOCL.g:365:1: ( rule__EssentialOCLUnreservedName__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnreservedNameAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:366:1: ( rule__EssentialOCLUnreservedName__Alternatives ) |
| // InternalEssentialOCL.g:366:2: rule__EssentialOCLUnreservedName__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__EssentialOCLUnreservedName__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnreservedNameAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEssentialOCLUnreservedName" |
| |
| |
| // $ANTLR start "entryRuleUnreservedName" |
| // InternalEssentialOCL.g:378:1: entryRuleUnreservedName : ruleUnreservedName EOF ; |
| public final void entryRuleUnreservedName() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:379:1: ( ruleUnreservedName EOF ) |
| // InternalEssentialOCL.g:380:1: ruleUnreservedName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUnreservedNameRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleUnreservedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUnreservedNameRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleUnreservedName" |
| |
| |
| // $ANTLR start "ruleUnreservedName" |
| // InternalEssentialOCL.g:387:1: ruleUnreservedName : ( ruleEssentialOCLUnreservedName ) ; |
| public final void ruleUnreservedName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:391:2: ( ( ruleEssentialOCLUnreservedName ) ) |
| // InternalEssentialOCL.g:392:1: ( ruleEssentialOCLUnreservedName ) |
| { |
| // InternalEssentialOCL.g:392:1: ( ruleEssentialOCLUnreservedName ) |
| // InternalEssentialOCL.g:393:1: ruleEssentialOCLUnreservedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUnreservedNameAccess().getEssentialOCLUnreservedNameParserRuleCall()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleEssentialOCLUnreservedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUnreservedNameAccess().getEssentialOCLUnreservedNameParserRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleUnreservedName" |
| |
| |
| // $ANTLR start "entryRuleURIFirstPathElementCS" |
| // InternalEssentialOCL.g:408:1: entryRuleURIFirstPathElementCS : ruleURIFirstPathElementCS EOF ; |
| public final void entryRuleURIFirstPathElementCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:409:1: ( ruleURIFirstPathElementCS EOF ) |
| // InternalEssentialOCL.g:410:1: ruleURIFirstPathElementCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIFirstPathElementCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleURIFirstPathElementCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIFirstPathElementCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleURIFirstPathElementCS" |
| |
| |
| // $ANTLR start "ruleURIFirstPathElementCS" |
| // InternalEssentialOCL.g:417:1: ruleURIFirstPathElementCS : ( ( rule__URIFirstPathElementCS__Alternatives ) ) ; |
| public final void ruleURIFirstPathElementCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:421:2: ( ( ( rule__URIFirstPathElementCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:422:1: ( ( rule__URIFirstPathElementCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:422:1: ( ( rule__URIFirstPathElementCS__Alternatives ) ) |
| // InternalEssentialOCL.g:423:1: ( rule__URIFirstPathElementCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIFirstPathElementCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:424:1: ( rule__URIFirstPathElementCS__Alternatives ) |
| // InternalEssentialOCL.g:424:2: rule__URIFirstPathElementCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__URIFirstPathElementCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIFirstPathElementCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleURIFirstPathElementCS" |
| |
| |
| // $ANTLR start "entryRulePrimitiveTypeIdentifier" |
| // InternalEssentialOCL.g:438:1: entryRulePrimitiveTypeIdentifier : rulePrimitiveTypeIdentifier EOF ; |
| public final void entryRulePrimitiveTypeIdentifier() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:439:1: ( rulePrimitiveTypeIdentifier EOF ) |
| // InternalEssentialOCL.g:440:1: rulePrimitiveTypeIdentifier EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeIdentifierRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| rulePrimitiveTypeIdentifier(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeIdentifierRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePrimitiveTypeIdentifier" |
| |
| |
| // $ANTLR start "rulePrimitiveTypeIdentifier" |
| // InternalEssentialOCL.g:447:1: rulePrimitiveTypeIdentifier : ( ( rule__PrimitiveTypeIdentifier__Alternatives ) ) ; |
| public final void rulePrimitiveTypeIdentifier() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:451:2: ( ( ( rule__PrimitiveTypeIdentifier__Alternatives ) ) ) |
| // InternalEssentialOCL.g:452:1: ( ( rule__PrimitiveTypeIdentifier__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:452:1: ( ( rule__PrimitiveTypeIdentifier__Alternatives ) ) |
| // InternalEssentialOCL.g:453:1: ( rule__PrimitiveTypeIdentifier__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeIdentifierAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:454:1: ( rule__PrimitiveTypeIdentifier__Alternatives ) |
| // InternalEssentialOCL.g:454:2: rule__PrimitiveTypeIdentifier__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimitiveTypeIdentifier__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeIdentifierAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePrimitiveTypeIdentifier" |
| |
| |
| // $ANTLR start "entryRulePrimitiveTypeCS" |
| // InternalEssentialOCL.g:466:1: entryRulePrimitiveTypeCS : rulePrimitiveTypeCS EOF ; |
| public final void entryRulePrimitiveTypeCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:467:1: ( rulePrimitiveTypeCS EOF ) |
| // InternalEssentialOCL.g:468:1: rulePrimitiveTypeCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| rulePrimitiveTypeCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePrimitiveTypeCS" |
| |
| |
| // $ANTLR start "rulePrimitiveTypeCS" |
| // InternalEssentialOCL.g:475:1: rulePrimitiveTypeCS : ( ( rule__PrimitiveTypeCS__NameAssignment ) ) ; |
| public final void rulePrimitiveTypeCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:479:2: ( ( ( rule__PrimitiveTypeCS__NameAssignment ) ) ) |
| // InternalEssentialOCL.g:480:1: ( ( rule__PrimitiveTypeCS__NameAssignment ) ) |
| { |
| // InternalEssentialOCL.g:480:1: ( ( rule__PrimitiveTypeCS__NameAssignment ) ) |
| // InternalEssentialOCL.g:481:1: ( rule__PrimitiveTypeCS__NameAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeCSAccess().getNameAssignment()); |
| } |
| // InternalEssentialOCL.g:482:1: ( rule__PrimitiveTypeCS__NameAssignment ) |
| // InternalEssentialOCL.g:482:2: rule__PrimitiveTypeCS__NameAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimitiveTypeCS__NameAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeCSAccess().getNameAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePrimitiveTypeCS" |
| |
| |
| // $ANTLR start "entryRuleCollectionTypeIdentifier" |
| // InternalEssentialOCL.g:494:1: entryRuleCollectionTypeIdentifier : ruleCollectionTypeIdentifier EOF ; |
| public final void entryRuleCollectionTypeIdentifier() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:495:1: ( ruleCollectionTypeIdentifier EOF ) |
| // InternalEssentialOCL.g:496:1: ruleCollectionTypeIdentifier EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeIdentifierRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleCollectionTypeIdentifier(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeIdentifierRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleCollectionTypeIdentifier" |
| |
| |
| // $ANTLR start "ruleCollectionTypeIdentifier" |
| // InternalEssentialOCL.g:503:1: ruleCollectionTypeIdentifier : ( ( rule__CollectionTypeIdentifier__Alternatives ) ) ; |
| public final void ruleCollectionTypeIdentifier() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:507:2: ( ( ( rule__CollectionTypeIdentifier__Alternatives ) ) ) |
| // InternalEssentialOCL.g:508:1: ( ( rule__CollectionTypeIdentifier__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:508:1: ( ( rule__CollectionTypeIdentifier__Alternatives ) ) |
| // InternalEssentialOCL.g:509:1: ( rule__CollectionTypeIdentifier__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeIdentifierAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:510:1: ( rule__CollectionTypeIdentifier__Alternatives ) |
| // InternalEssentialOCL.g:510:2: rule__CollectionTypeIdentifier__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeIdentifier__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeIdentifierAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleCollectionTypeIdentifier" |
| |
| |
| // $ANTLR start "entryRuleCollectionTypeCS" |
| // InternalEssentialOCL.g:522:1: entryRuleCollectionTypeCS : ruleCollectionTypeCS EOF ; |
| public final void entryRuleCollectionTypeCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:523:1: ( ruleCollectionTypeCS EOF ) |
| // InternalEssentialOCL.g:524:1: ruleCollectionTypeCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleCollectionTypeCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleCollectionTypeCS" |
| |
| |
| // $ANTLR start "ruleCollectionTypeCS" |
| // InternalEssentialOCL.g:531:1: ruleCollectionTypeCS : ( ( rule__CollectionTypeCS__Group__0 ) ) ; |
| public final void ruleCollectionTypeCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:535:2: ( ( ( rule__CollectionTypeCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:536:1: ( ( rule__CollectionTypeCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:536:1: ( ( rule__CollectionTypeCS__Group__0 ) ) |
| // InternalEssentialOCL.g:537:1: ( rule__CollectionTypeCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:538:1: ( rule__CollectionTypeCS__Group__0 ) |
| // InternalEssentialOCL.g:538:2: rule__CollectionTypeCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleCollectionTypeCS" |
| |
| |
| // $ANTLR start "entryRuleMapTypeCS" |
| // InternalEssentialOCL.g:550:1: entryRuleMapTypeCS : ruleMapTypeCS EOF ; |
| public final void entryRuleMapTypeCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:551:1: ( ruleMapTypeCS EOF ) |
| // InternalEssentialOCL.g:552:1: ruleMapTypeCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleMapTypeCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleMapTypeCS" |
| |
| |
| // $ANTLR start "ruleMapTypeCS" |
| // InternalEssentialOCL.g:559:1: ruleMapTypeCS : ( ( rule__MapTypeCS__Group__0 ) ) ; |
| public final void ruleMapTypeCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:563:2: ( ( ( rule__MapTypeCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:564:1: ( ( rule__MapTypeCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:564:1: ( ( rule__MapTypeCS__Group__0 ) ) |
| // InternalEssentialOCL.g:565:1: ( rule__MapTypeCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:566:1: ( rule__MapTypeCS__Group__0 ) |
| // InternalEssentialOCL.g:566:2: rule__MapTypeCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleMapTypeCS" |
| |
| |
| // $ANTLR start "entryRuleTupleTypeCS" |
| // InternalEssentialOCL.g:578:1: entryRuleTupleTypeCS : ruleTupleTypeCS EOF ; |
| public final void entryRuleTupleTypeCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:579:1: ( ruleTupleTypeCS EOF ) |
| // InternalEssentialOCL.g:580:1: ruleTupleTypeCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTupleTypeCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTupleTypeCS" |
| |
| |
| // $ANTLR start "ruleTupleTypeCS" |
| // InternalEssentialOCL.g:587:1: ruleTupleTypeCS : ( ( rule__TupleTypeCS__Group__0 ) ) ; |
| public final void ruleTupleTypeCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:591:2: ( ( ( rule__TupleTypeCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:592:1: ( ( rule__TupleTypeCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:592:1: ( ( rule__TupleTypeCS__Group__0 ) ) |
| // InternalEssentialOCL.g:593:1: ( rule__TupleTypeCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:594:1: ( rule__TupleTypeCS__Group__0 ) |
| // InternalEssentialOCL.g:594:2: rule__TupleTypeCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTupleTypeCS" |
| |
| |
| // $ANTLR start "entryRuleTuplePartCS" |
| // InternalEssentialOCL.g:606:1: entryRuleTuplePartCS : ruleTuplePartCS EOF ; |
| public final void entryRuleTuplePartCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:607:1: ( ruleTuplePartCS EOF ) |
| // InternalEssentialOCL.g:608:1: ruleTuplePartCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTuplePartCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTuplePartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTuplePartCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTuplePartCS" |
| |
| |
| // $ANTLR start "ruleTuplePartCS" |
| // InternalEssentialOCL.g:615:1: ruleTuplePartCS : ( ( rule__TuplePartCS__Group__0 ) ) ; |
| public final void ruleTuplePartCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:619:2: ( ( ( rule__TuplePartCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:620:1: ( ( rule__TuplePartCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:620:1: ( ( rule__TuplePartCS__Group__0 ) ) |
| // InternalEssentialOCL.g:621:1: ( rule__TuplePartCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTuplePartCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:622:1: ( rule__TuplePartCS__Group__0 ) |
| // InternalEssentialOCL.g:622:2: rule__TuplePartCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TuplePartCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTuplePartCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTuplePartCS" |
| |
| |
| // $ANTLR start "entryRuleCollectionLiteralExpCS" |
| // InternalEssentialOCL.g:634:1: entryRuleCollectionLiteralExpCS : ruleCollectionLiteralExpCS EOF ; |
| public final void entryRuleCollectionLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:635:1: ( ruleCollectionLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:636:1: ruleCollectionLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleCollectionLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleCollectionLiteralExpCS" |
| |
| |
| // $ANTLR start "ruleCollectionLiteralExpCS" |
| // InternalEssentialOCL.g:643:1: ruleCollectionLiteralExpCS : ( ( rule__CollectionLiteralExpCS__Group__0 ) ) ; |
| public final void ruleCollectionLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:647:2: ( ( ( rule__CollectionLiteralExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:648:1: ( ( rule__CollectionLiteralExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:648:1: ( ( rule__CollectionLiteralExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:649:1: ( rule__CollectionLiteralExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:650:1: ( rule__CollectionLiteralExpCS__Group__0 ) |
| // InternalEssentialOCL.g:650:2: rule__CollectionLiteralExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleCollectionLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleCollectionLiteralPartCS" |
| // InternalEssentialOCL.g:662:1: entryRuleCollectionLiteralPartCS : ruleCollectionLiteralPartCS EOF ; |
| public final void entryRuleCollectionLiteralPartCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:663:1: ( ruleCollectionLiteralPartCS EOF ) |
| // InternalEssentialOCL.g:664:1: ruleCollectionLiteralPartCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralPartCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleCollectionLiteralPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralPartCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleCollectionLiteralPartCS" |
| |
| |
| // $ANTLR start "ruleCollectionLiteralPartCS" |
| // InternalEssentialOCL.g:671:1: ruleCollectionLiteralPartCS : ( ( rule__CollectionLiteralPartCS__Alternatives ) ) ; |
| public final void ruleCollectionLiteralPartCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:675:2: ( ( ( rule__CollectionLiteralPartCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:676:1: ( ( rule__CollectionLiteralPartCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:676:1: ( ( rule__CollectionLiteralPartCS__Alternatives ) ) |
| // InternalEssentialOCL.g:677:1: ( rule__CollectionLiteralPartCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralPartCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:678:1: ( rule__CollectionLiteralPartCS__Alternatives ) |
| // InternalEssentialOCL.g:678:2: rule__CollectionLiteralPartCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralPartCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralPartCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleCollectionLiteralPartCS" |
| |
| |
| // $ANTLR start "entryRuleCollectionPatternCS" |
| // InternalEssentialOCL.g:690:1: entryRuleCollectionPatternCS : ruleCollectionPatternCS EOF ; |
| public final void entryRuleCollectionPatternCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:691:1: ( ruleCollectionPatternCS EOF ) |
| // InternalEssentialOCL.g:692:1: ruleCollectionPatternCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleCollectionPatternCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleCollectionPatternCS" |
| |
| |
| // $ANTLR start "ruleCollectionPatternCS" |
| // InternalEssentialOCL.g:699:1: ruleCollectionPatternCS : ( ( rule__CollectionPatternCS__Group__0 ) ) ; |
| public final void ruleCollectionPatternCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:703:2: ( ( ( rule__CollectionPatternCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:704:1: ( ( rule__CollectionPatternCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:704:1: ( ( rule__CollectionPatternCS__Group__0 ) ) |
| // InternalEssentialOCL.g:705:1: ( rule__CollectionPatternCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:706:1: ( rule__CollectionPatternCS__Group__0 ) |
| // InternalEssentialOCL.g:706:2: rule__CollectionPatternCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleCollectionPatternCS" |
| |
| |
| // $ANTLR start "entryRuleShadowPartCS" |
| // InternalEssentialOCL.g:718:1: entryRuleShadowPartCS : ruleShadowPartCS EOF ; |
| public final void entryRuleShadowPartCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:719:1: ( ruleShadowPartCS EOF ) |
| // InternalEssentialOCL.g:720:1: ruleShadowPartCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleShadowPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleShadowPartCS" |
| |
| |
| // $ANTLR start "ruleShadowPartCS" |
| // InternalEssentialOCL.g:727:1: ruleShadowPartCS : ( ( rule__ShadowPartCS__Alternatives ) ) ; |
| public final void ruleShadowPartCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:731:2: ( ( ( rule__ShadowPartCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:732:1: ( ( rule__ShadowPartCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:732:1: ( ( rule__ShadowPartCS__Alternatives ) ) |
| // InternalEssentialOCL.g:733:1: ( rule__ShadowPartCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:734:1: ( rule__ShadowPartCS__Alternatives ) |
| // InternalEssentialOCL.g:734:2: rule__ShadowPartCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ShadowPartCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleShadowPartCS" |
| |
| |
| // $ANTLR start "entryRulePatternExpCS" |
| // InternalEssentialOCL.g:746:1: entryRulePatternExpCS : rulePatternExpCS EOF ; |
| public final void entryRulePatternExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:747:1: ( rulePatternExpCS EOF ) |
| // InternalEssentialOCL.g:748:1: rulePatternExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPatternExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| rulePatternExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPatternExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePatternExpCS" |
| |
| |
| // $ANTLR start "rulePatternExpCS" |
| // InternalEssentialOCL.g:755:1: rulePatternExpCS : ( ( rule__PatternExpCS__Group__0 ) ) ; |
| public final void rulePatternExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:759:2: ( ( ( rule__PatternExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:760:1: ( ( rule__PatternExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:760:1: ( ( rule__PatternExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:761:1: ( rule__PatternExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPatternExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:762:1: ( rule__PatternExpCS__Group__0 ) |
| // InternalEssentialOCL.g:762:2: rule__PatternExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PatternExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPatternExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePatternExpCS" |
| |
| |
| // $ANTLR start "entryRuleLambdaLiteralExpCS" |
| // InternalEssentialOCL.g:774:1: entryRuleLambdaLiteralExpCS : ruleLambdaLiteralExpCS EOF ; |
| public final void entryRuleLambdaLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:775:1: ( ruleLambdaLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:776:1: ruleLambdaLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLambdaLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLambdaLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLambdaLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLambdaLiteralExpCS" |
| |
| |
| // $ANTLR start "ruleLambdaLiteralExpCS" |
| // InternalEssentialOCL.g:783:1: ruleLambdaLiteralExpCS : ( ( rule__LambdaLiteralExpCS__Group__0 ) ) ; |
| public final void ruleLambdaLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:787:2: ( ( ( rule__LambdaLiteralExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:788:1: ( ( rule__LambdaLiteralExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:788:1: ( ( rule__LambdaLiteralExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:789:1: ( rule__LambdaLiteralExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLambdaLiteralExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:790:1: ( rule__LambdaLiteralExpCS__Group__0 ) |
| // InternalEssentialOCL.g:790:2: rule__LambdaLiteralExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LambdaLiteralExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLambdaLiteralExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLambdaLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleMapLiteralExpCS" |
| // InternalEssentialOCL.g:802:1: entryRuleMapLiteralExpCS : ruleMapLiteralExpCS EOF ; |
| public final void entryRuleMapLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:803:1: ( ruleMapLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:804:1: ruleMapLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleMapLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleMapLiteralExpCS" |
| |
| |
| // $ANTLR start "ruleMapLiteralExpCS" |
| // InternalEssentialOCL.g:811:1: ruleMapLiteralExpCS : ( ( rule__MapLiteralExpCS__Group__0 ) ) ; |
| public final void ruleMapLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:815:2: ( ( ( rule__MapLiteralExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:816:1: ( ( rule__MapLiteralExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:816:1: ( ( rule__MapLiteralExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:817:1: ( rule__MapLiteralExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:818:1: ( rule__MapLiteralExpCS__Group__0 ) |
| // InternalEssentialOCL.g:818:2: rule__MapLiteralExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleMapLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleMapLiteralPartCS" |
| // InternalEssentialOCL.g:830:1: entryRuleMapLiteralPartCS : ruleMapLiteralPartCS EOF ; |
| public final void entryRuleMapLiteralPartCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:831:1: ( ruleMapLiteralPartCS EOF ) |
| // InternalEssentialOCL.g:832:1: ruleMapLiteralPartCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralPartCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleMapLiteralPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralPartCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleMapLiteralPartCS" |
| |
| |
| // $ANTLR start "ruleMapLiteralPartCS" |
| // InternalEssentialOCL.g:839:1: ruleMapLiteralPartCS : ( ( rule__MapLiteralPartCS__Group__0 ) ) ; |
| public final void ruleMapLiteralPartCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:843:2: ( ( ( rule__MapLiteralPartCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:844:1: ( ( rule__MapLiteralPartCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:844:1: ( ( rule__MapLiteralPartCS__Group__0 ) ) |
| // InternalEssentialOCL.g:845:1: ( rule__MapLiteralPartCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralPartCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:846:1: ( rule__MapLiteralPartCS__Group__0 ) |
| // InternalEssentialOCL.g:846:2: rule__MapLiteralPartCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralPartCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralPartCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleMapLiteralPartCS" |
| |
| |
| // $ANTLR start "entryRulePrimitiveLiteralExpCS" |
| // InternalEssentialOCL.g:858:1: entryRulePrimitiveLiteralExpCS : rulePrimitiveLiteralExpCS EOF ; |
| public final void entryRulePrimitiveLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:859:1: ( rulePrimitiveLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:860:1: rulePrimitiveLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| rulePrimitiveLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePrimitiveLiteralExpCS" |
| |
| |
| // $ANTLR start "rulePrimitiveLiteralExpCS" |
| // InternalEssentialOCL.g:867:1: rulePrimitiveLiteralExpCS : ( ( rule__PrimitiveLiteralExpCS__Alternatives ) ) ; |
| public final void rulePrimitiveLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:871:2: ( ( ( rule__PrimitiveLiteralExpCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:872:1: ( ( rule__PrimitiveLiteralExpCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:872:1: ( ( rule__PrimitiveLiteralExpCS__Alternatives ) ) |
| // InternalEssentialOCL.g:873:1: ( rule__PrimitiveLiteralExpCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveLiteralExpCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:874:1: ( rule__PrimitiveLiteralExpCS__Alternatives ) |
| // InternalEssentialOCL.g:874:2: rule__PrimitiveLiteralExpCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimitiveLiteralExpCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveLiteralExpCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePrimitiveLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleTupleLiteralExpCS" |
| // InternalEssentialOCL.g:886:1: entryRuleTupleLiteralExpCS : ruleTupleLiteralExpCS EOF ; |
| public final void entryRuleTupleLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:887:1: ( ruleTupleLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:888:1: ruleTupleLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTupleLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTupleLiteralExpCS" |
| |
| |
| // $ANTLR start "ruleTupleLiteralExpCS" |
| // InternalEssentialOCL.g:895:1: ruleTupleLiteralExpCS : ( ( rule__TupleLiteralExpCS__Group__0 ) ) ; |
| public final void ruleTupleLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:899:2: ( ( ( rule__TupleLiteralExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:900:1: ( ( rule__TupleLiteralExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:900:1: ( ( rule__TupleLiteralExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:901:1: ( rule__TupleLiteralExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:902:1: ( rule__TupleLiteralExpCS__Group__0 ) |
| // InternalEssentialOCL.g:902:2: rule__TupleLiteralExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTupleLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleTupleLiteralPartCS" |
| // InternalEssentialOCL.g:914:1: entryRuleTupleLiteralPartCS : ruleTupleLiteralPartCS EOF ; |
| public final void entryRuleTupleLiteralPartCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:915:1: ( ruleTupleLiteralPartCS EOF ) |
| // InternalEssentialOCL.g:916:1: ruleTupleLiteralPartCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralPartCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTupleLiteralPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralPartCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTupleLiteralPartCS" |
| |
| |
| // $ANTLR start "ruleTupleLiteralPartCS" |
| // InternalEssentialOCL.g:923:1: ruleTupleLiteralPartCS : ( ( rule__TupleLiteralPartCS__Group__0 ) ) ; |
| public final void ruleTupleLiteralPartCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:927:2: ( ( ( rule__TupleLiteralPartCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:928:1: ( ( rule__TupleLiteralPartCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:928:1: ( ( rule__TupleLiteralPartCS__Group__0 ) ) |
| // InternalEssentialOCL.g:929:1: ( rule__TupleLiteralPartCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralPartCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:930:1: ( rule__TupleLiteralPartCS__Group__0 ) |
| // InternalEssentialOCL.g:930:2: rule__TupleLiteralPartCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralPartCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralPartCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTupleLiteralPartCS" |
| |
| |
| // $ANTLR start "entryRuleNumberLiteralExpCS" |
| // InternalEssentialOCL.g:942:1: entryRuleNumberLiteralExpCS : ruleNumberLiteralExpCS EOF ; |
| public final void entryRuleNumberLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:943:1: ( ruleNumberLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:944:1: ruleNumberLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumberLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNumberLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumberLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNumberLiteralExpCS" |
| |
| |
| // $ANTLR start "ruleNumberLiteralExpCS" |
| // InternalEssentialOCL.g:951:1: ruleNumberLiteralExpCS : ( ( rule__NumberLiteralExpCS__SymbolAssignment ) ) ; |
| public final void ruleNumberLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:955:2: ( ( ( rule__NumberLiteralExpCS__SymbolAssignment ) ) ) |
| // InternalEssentialOCL.g:956:1: ( ( rule__NumberLiteralExpCS__SymbolAssignment ) ) |
| { |
| // InternalEssentialOCL.g:956:1: ( ( rule__NumberLiteralExpCS__SymbolAssignment ) ) |
| // InternalEssentialOCL.g:957:1: ( rule__NumberLiteralExpCS__SymbolAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumberLiteralExpCSAccess().getSymbolAssignment()); |
| } |
| // InternalEssentialOCL.g:958:1: ( rule__NumberLiteralExpCS__SymbolAssignment ) |
| // InternalEssentialOCL.g:958:2: rule__NumberLiteralExpCS__SymbolAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NumberLiteralExpCS__SymbolAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumberLiteralExpCSAccess().getSymbolAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNumberLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleStringLiteralExpCS" |
| // InternalEssentialOCL.g:970:1: entryRuleStringLiteralExpCS : ruleStringLiteralExpCS EOF ; |
| public final void entryRuleStringLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:971:1: ( ruleStringLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:972:1: ruleStringLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleStringLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleStringLiteralExpCS" |
| |
| |
| // $ANTLR start "ruleStringLiteralExpCS" |
| // InternalEssentialOCL.g:979:1: ruleStringLiteralExpCS : ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) ) ; |
| public final void ruleStringLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:983:2: ( ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) ) ) |
| // InternalEssentialOCL.g:984:1: ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) ) |
| { |
| // InternalEssentialOCL.g:984:1: ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) ) |
| // InternalEssentialOCL.g:985:1: ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) |
| { |
| // InternalEssentialOCL.g:985:1: ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) |
| // InternalEssentialOCL.g:986:1: ( rule__StringLiteralExpCS__SegmentsAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment()); |
| } |
| // InternalEssentialOCL.g:987:1: ( rule__StringLiteralExpCS__SegmentsAssignment ) |
| // InternalEssentialOCL.g:987:2: rule__StringLiteralExpCS__SegmentsAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_3); |
| rule__StringLiteralExpCS__SegmentsAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment()); |
| } |
| |
| } |
| |
| // InternalEssentialOCL.g:990:1: ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) |
| // InternalEssentialOCL.g:991:1: ( rule__StringLiteralExpCS__SegmentsAssignment )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment()); |
| } |
| // InternalEssentialOCL.g:992:1: ( rule__StringLiteralExpCS__SegmentsAssignment )* |
| loop1: |
| do { |
| int alt1=2; |
| int LA1_0 = input.LA(1); |
| |
| if ( (LA1_0==RULE_SINGLE_QUOTED_STRING) ) { |
| alt1=1; |
| } |
| |
| |
| switch (alt1) { |
| case 1 : |
| // InternalEssentialOCL.g:992:2: rule__StringLiteralExpCS__SegmentsAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_3); |
| rule__StringLiteralExpCS__SegmentsAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop1; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleStringLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleBooleanLiteralExpCS" |
| // InternalEssentialOCL.g:1005:1: entryRuleBooleanLiteralExpCS : ruleBooleanLiteralExpCS EOF ; |
| public final void entryRuleBooleanLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1006:1: ( ruleBooleanLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:1007:1: ruleBooleanLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBooleanLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleBooleanLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBooleanLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleBooleanLiteralExpCS" |
| |
| |
| // $ANTLR start "ruleBooleanLiteralExpCS" |
| // InternalEssentialOCL.g:1014:1: ruleBooleanLiteralExpCS : ( ( rule__BooleanLiteralExpCS__Alternatives ) ) ; |
| public final void ruleBooleanLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1018:2: ( ( ( rule__BooleanLiteralExpCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:1019:1: ( ( rule__BooleanLiteralExpCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:1019:1: ( ( rule__BooleanLiteralExpCS__Alternatives ) ) |
| // InternalEssentialOCL.g:1020:1: ( rule__BooleanLiteralExpCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBooleanLiteralExpCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:1021:1: ( rule__BooleanLiteralExpCS__Alternatives ) |
| // InternalEssentialOCL.g:1021:2: rule__BooleanLiteralExpCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__BooleanLiteralExpCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBooleanLiteralExpCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleBooleanLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleUnlimitedNaturalLiteralExpCS" |
| // InternalEssentialOCL.g:1033:1: entryRuleUnlimitedNaturalLiteralExpCS : ruleUnlimitedNaturalLiteralExpCS EOF ; |
| public final void entryRuleUnlimitedNaturalLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1034:1: ( ruleUnlimitedNaturalLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:1035:1: ruleUnlimitedNaturalLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUnlimitedNaturalLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleUnlimitedNaturalLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUnlimitedNaturalLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleUnlimitedNaturalLiteralExpCS" |
| |
| |
| // $ANTLR start "ruleUnlimitedNaturalLiteralExpCS" |
| // InternalEssentialOCL.g:1042:1: ruleUnlimitedNaturalLiteralExpCS : ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) ) ; |
| public final void ruleUnlimitedNaturalLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1046:2: ( ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1047:1: ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1047:1: ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1048:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1049:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) |
| // InternalEssentialOCL.g:1049:2: rule__UnlimitedNaturalLiteralExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__UnlimitedNaturalLiteralExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleUnlimitedNaturalLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleInvalidLiteralExpCS" |
| // InternalEssentialOCL.g:1061:1: entryRuleInvalidLiteralExpCS : ruleInvalidLiteralExpCS EOF ; |
| public final void entryRuleInvalidLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1062:1: ( ruleInvalidLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:1063:1: ruleInvalidLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInvalidLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleInvalidLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInvalidLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleInvalidLiteralExpCS" |
| |
| |
| // $ANTLR start "ruleInvalidLiteralExpCS" |
| // InternalEssentialOCL.g:1070:1: ruleInvalidLiteralExpCS : ( ( rule__InvalidLiteralExpCS__Group__0 ) ) ; |
| public final void ruleInvalidLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1074:2: ( ( ( rule__InvalidLiteralExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1075:1: ( ( rule__InvalidLiteralExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1075:1: ( ( rule__InvalidLiteralExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1076:1: ( rule__InvalidLiteralExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInvalidLiteralExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1077:1: ( rule__InvalidLiteralExpCS__Group__0 ) |
| // InternalEssentialOCL.g:1077:2: rule__InvalidLiteralExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__InvalidLiteralExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInvalidLiteralExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleInvalidLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleNullLiteralExpCS" |
| // InternalEssentialOCL.g:1089:1: entryRuleNullLiteralExpCS : ruleNullLiteralExpCS EOF ; |
| public final void entryRuleNullLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1090:1: ( ruleNullLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:1091:1: ruleNullLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNullLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNullLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNullLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNullLiteralExpCS" |
| |
| |
| // $ANTLR start "ruleNullLiteralExpCS" |
| // InternalEssentialOCL.g:1098:1: ruleNullLiteralExpCS : ( ( rule__NullLiteralExpCS__Group__0 ) ) ; |
| public final void ruleNullLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1102:2: ( ( ( rule__NullLiteralExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1103:1: ( ( rule__NullLiteralExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1103:1: ( ( rule__NullLiteralExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1104:1: ( rule__NullLiteralExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNullLiteralExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1105:1: ( rule__NullLiteralExpCS__Group__0 ) |
| // InternalEssentialOCL.g:1105:2: rule__NullLiteralExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NullLiteralExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNullLiteralExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNullLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleTypeLiteralCS" |
| // InternalEssentialOCL.g:1117:1: entryRuleTypeLiteralCS : ruleTypeLiteralCS EOF ; |
| public final void entryRuleTypeLiteralCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1118:1: ( ruleTypeLiteralCS EOF ) |
| // InternalEssentialOCL.g:1119:1: ruleTypeLiteralCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTypeLiteralCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTypeLiteralCS" |
| |
| |
| // $ANTLR start "ruleTypeLiteralCS" |
| // InternalEssentialOCL.g:1126:1: ruleTypeLiteralCS : ( ( rule__TypeLiteralCS__Alternatives ) ) ; |
| public final void ruleTypeLiteralCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1130:2: ( ( ( rule__TypeLiteralCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:1131:1: ( ( rule__TypeLiteralCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:1131:1: ( ( rule__TypeLiteralCS__Alternatives ) ) |
| // InternalEssentialOCL.g:1132:1: ( rule__TypeLiteralCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:1133:1: ( rule__TypeLiteralCS__Alternatives ) |
| // InternalEssentialOCL.g:1133:2: rule__TypeLiteralCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeLiteralCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTypeLiteralCS" |
| |
| |
| // $ANTLR start "entryRuleTypeLiteralWithMultiplicityCS" |
| // InternalEssentialOCL.g:1145:1: entryRuleTypeLiteralWithMultiplicityCS : ruleTypeLiteralWithMultiplicityCS EOF ; |
| public final void entryRuleTypeLiteralWithMultiplicityCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1146:1: ( ruleTypeLiteralWithMultiplicityCS EOF ) |
| // InternalEssentialOCL.g:1147:1: ruleTypeLiteralWithMultiplicityCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralWithMultiplicityCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTypeLiteralWithMultiplicityCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralWithMultiplicityCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTypeLiteralWithMultiplicityCS" |
| |
| |
| // $ANTLR start "ruleTypeLiteralWithMultiplicityCS" |
| // InternalEssentialOCL.g:1154:1: ruleTypeLiteralWithMultiplicityCS : ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) ) ; |
| public final void ruleTypeLiteralWithMultiplicityCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1158:2: ( ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1159:1: ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1159:1: ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1160:1: ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1161:1: ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) |
| // InternalEssentialOCL.g:1161:2: rule__TypeLiteralWithMultiplicityCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeLiteralWithMultiplicityCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTypeLiteralWithMultiplicityCS" |
| |
| |
| // $ANTLR start "entryRuleTypeLiteralExpCS" |
| // InternalEssentialOCL.g:1173:1: entryRuleTypeLiteralExpCS : ruleTypeLiteralExpCS EOF ; |
| public final void entryRuleTypeLiteralExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1174:1: ( ruleTypeLiteralExpCS EOF ) |
| // InternalEssentialOCL.g:1175:1: ruleTypeLiteralExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTypeLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTypeLiteralExpCS" |
| |
| |
| // $ANTLR start "ruleTypeLiteralExpCS" |
| // InternalEssentialOCL.g:1182:1: ruleTypeLiteralExpCS : ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) ) ; |
| public final void ruleTypeLiteralExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1186:2: ( ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) ) ) |
| // InternalEssentialOCL.g:1187:1: ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) ) |
| { |
| // InternalEssentialOCL.g:1187:1: ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) ) |
| // InternalEssentialOCL.g:1188:1: ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeAssignment()); |
| } |
| // InternalEssentialOCL.g:1189:1: ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) |
| // InternalEssentialOCL.g:1189:2: rule__TypeLiteralExpCS__OwnedTypeAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeLiteralExpCS__OwnedTypeAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTypeLiteralExpCS" |
| |
| |
| // $ANTLR start "entryRuleTypeNameExpCS" |
| // InternalEssentialOCL.g:1201:1: entryRuleTypeNameExpCS : ruleTypeNameExpCS EOF ; |
| public final void entryRuleTypeNameExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1202:1: ( ruleTypeNameExpCS EOF ) |
| // InternalEssentialOCL.g:1203:1: ruleTypeNameExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTypeNameExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTypeNameExpCS" |
| |
| |
| // $ANTLR start "ruleTypeNameExpCS" |
| // InternalEssentialOCL.g:1210:1: ruleTypeNameExpCS : ( ( rule__TypeNameExpCS__Group__0 ) ) ; |
| public final void ruleTypeNameExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1214:2: ( ( ( rule__TypeNameExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1215:1: ( ( rule__TypeNameExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1215:1: ( ( rule__TypeNameExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1216:1: ( rule__TypeNameExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1217:1: ( rule__TypeNameExpCS__Group__0 ) |
| // InternalEssentialOCL.g:1217:2: rule__TypeNameExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTypeNameExpCS" |
| |
| |
| // $ANTLR start "entryRuleTypeExpWithoutMultiplicityCS" |
| // InternalEssentialOCL.g:1229:1: entryRuleTypeExpWithoutMultiplicityCS : ruleTypeExpWithoutMultiplicityCS EOF ; |
| public final void entryRuleTypeExpWithoutMultiplicityCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1230:1: ( ruleTypeExpWithoutMultiplicityCS EOF ) |
| // InternalEssentialOCL.g:1231:1: ruleTypeExpWithoutMultiplicityCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeExpWithoutMultiplicityCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTypeExpWithoutMultiplicityCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeExpWithoutMultiplicityCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTypeExpWithoutMultiplicityCS" |
| |
| |
| // $ANTLR start "ruleTypeExpWithoutMultiplicityCS" |
| // InternalEssentialOCL.g:1238:1: ruleTypeExpWithoutMultiplicityCS : ( ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) ) ; |
| public final void ruleTypeExpWithoutMultiplicityCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1242:2: ( ( ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:1243:1: ( ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:1243:1: ( ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) ) |
| // InternalEssentialOCL.g:1244:1: ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:1245:1: ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) |
| // InternalEssentialOCL.g:1245:2: rule__TypeExpWithoutMultiplicityCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeExpWithoutMultiplicityCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTypeExpWithoutMultiplicityCS" |
| |
| |
| // $ANTLR start "entryRuleTypeExpCS" |
| // InternalEssentialOCL.g:1257:1: entryRuleTypeExpCS : ruleTypeExpCS EOF ; |
| public final void entryRuleTypeExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1258:1: ( ruleTypeExpCS EOF ) |
| // InternalEssentialOCL.g:1259:1: ruleTypeExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTypeExpCS" |
| |
| |
| // $ANTLR start "ruleTypeExpCS" |
| // InternalEssentialOCL.g:1266:1: ruleTypeExpCS : ( ( rule__TypeExpCS__Group__0 ) ) ; |
| public final void ruleTypeExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1270:2: ( ( ( rule__TypeExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1271:1: ( ( rule__TypeExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1271:1: ( ( rule__TypeExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1272:1: ( rule__TypeExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1273:1: ( rule__TypeExpCS__Group__0 ) |
| // InternalEssentialOCL.g:1273:2: rule__TypeExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTypeExpCS" |
| |
| |
| // $ANTLR start "entryRuleExpCS" |
| // InternalEssentialOCL.g:1285:1: entryRuleExpCS : ruleExpCS EOF ; |
| public final void entryRuleExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1286:1: ( ruleExpCS EOF ) |
| // InternalEssentialOCL.g:1287:1: ruleExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleExpCS" |
| |
| |
| // $ANTLR start "ruleExpCS" |
| // InternalEssentialOCL.g:1294:1: ruleExpCS : ( ( rule__ExpCS__Alternatives ) ) ; |
| public final void ruleExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1298:2: ( ( ( rule__ExpCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:1299:1: ( ( rule__ExpCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:1299:1: ( ( rule__ExpCS__Alternatives ) ) |
| // InternalEssentialOCL.g:1300:1: ( rule__ExpCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:1301:1: ( rule__ExpCS__Alternatives ) |
| // InternalEssentialOCL.g:1301:2: rule__ExpCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ExpCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleExpCS" |
| |
| |
| // $ANTLR start "entryRulePrefixedLetExpCS" |
| // InternalEssentialOCL.g:1313:1: entryRulePrefixedLetExpCS : rulePrefixedLetExpCS EOF ; |
| public final void entryRulePrefixedLetExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1314:1: ( rulePrefixedLetExpCS EOF ) |
| // InternalEssentialOCL.g:1315:1: rulePrefixedLetExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedLetExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| rulePrefixedLetExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedLetExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePrefixedLetExpCS" |
| |
| |
| // $ANTLR start "rulePrefixedLetExpCS" |
| // InternalEssentialOCL.g:1322:1: rulePrefixedLetExpCS : ( ( rule__PrefixedLetExpCS__Alternatives ) ) ; |
| public final void rulePrefixedLetExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1326:2: ( ( ( rule__PrefixedLetExpCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:1327:1: ( ( rule__PrefixedLetExpCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:1327:1: ( ( rule__PrefixedLetExpCS__Alternatives ) ) |
| // InternalEssentialOCL.g:1328:1: ( rule__PrefixedLetExpCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedLetExpCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:1329:1: ( rule__PrefixedLetExpCS__Alternatives ) |
| // InternalEssentialOCL.g:1329:2: rule__PrefixedLetExpCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedLetExpCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedLetExpCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePrefixedLetExpCS" |
| |
| |
| // $ANTLR start "entryRulePrefixedPrimaryExpCS" |
| // InternalEssentialOCL.g:1341:1: entryRulePrefixedPrimaryExpCS : rulePrefixedPrimaryExpCS EOF ; |
| public final void entryRulePrefixedPrimaryExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1342:1: ( rulePrefixedPrimaryExpCS EOF ) |
| // InternalEssentialOCL.g:1343:1: rulePrefixedPrimaryExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedPrimaryExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| rulePrefixedPrimaryExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedPrimaryExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePrefixedPrimaryExpCS" |
| |
| |
| // $ANTLR start "rulePrefixedPrimaryExpCS" |
| // InternalEssentialOCL.g:1350:1: rulePrefixedPrimaryExpCS : ( ( rule__PrefixedPrimaryExpCS__Alternatives ) ) ; |
| public final void rulePrefixedPrimaryExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1354:2: ( ( ( rule__PrefixedPrimaryExpCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:1355:1: ( ( rule__PrefixedPrimaryExpCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:1355:1: ( ( rule__PrefixedPrimaryExpCS__Alternatives ) ) |
| // InternalEssentialOCL.g:1356:1: ( rule__PrefixedPrimaryExpCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedPrimaryExpCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:1357:1: ( rule__PrefixedPrimaryExpCS__Alternatives ) |
| // InternalEssentialOCL.g:1357:2: rule__PrefixedPrimaryExpCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedPrimaryExpCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedPrimaryExpCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePrefixedPrimaryExpCS" |
| |
| |
| // $ANTLR start "entryRulePrimaryExpCS" |
| // InternalEssentialOCL.g:1369:1: entryRulePrimaryExpCS : rulePrimaryExpCS EOF ; |
| public final void entryRulePrimaryExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1370:1: ( rulePrimaryExpCS EOF ) |
| // InternalEssentialOCL.g:1371:1: rulePrimaryExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| rulePrimaryExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePrimaryExpCS" |
| |
| |
| // $ANTLR start "rulePrimaryExpCS" |
| // InternalEssentialOCL.g:1378:1: rulePrimaryExpCS : ( ( rule__PrimaryExpCS__Alternatives ) ) ; |
| public final void rulePrimaryExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1382:2: ( ( ( rule__PrimaryExpCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:1383:1: ( ( rule__PrimaryExpCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:1383:1: ( ( rule__PrimaryExpCS__Alternatives ) ) |
| // InternalEssentialOCL.g:1384:1: ( rule__PrimaryExpCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:1385:1: ( rule__PrimaryExpCS__Alternatives ) |
| // InternalEssentialOCL.g:1385:2: rule__PrimaryExpCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrimaryExpCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePrimaryExpCS" |
| |
| |
| // $ANTLR start "entryRuleNameExpCS" |
| // InternalEssentialOCL.g:1397:1: entryRuleNameExpCS : ruleNameExpCS EOF ; |
| public final void entryRuleNameExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1398:1: ( ruleNameExpCS EOF ) |
| // InternalEssentialOCL.g:1399:1: ruleNameExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNameExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNameExpCS" |
| |
| |
| // $ANTLR start "ruleNameExpCS" |
| // InternalEssentialOCL.g:1406:1: ruleNameExpCS : ( ( rule__NameExpCS__Group__0 ) ) ; |
| public final void ruleNameExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1410:2: ( ( ( rule__NameExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1411:1: ( ( rule__NameExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1411:1: ( ( rule__NameExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1412:1: ( rule__NameExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1413:1: ( rule__NameExpCS__Group__0 ) |
| // InternalEssentialOCL.g:1413:2: rule__NameExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNameExpCS" |
| |
| |
| // $ANTLR start "entryRuleCurlyBracketedClauseCS" |
| // InternalEssentialOCL.g:1425:1: entryRuleCurlyBracketedClauseCS : ruleCurlyBracketedClauseCS EOF ; |
| public final void entryRuleCurlyBracketedClauseCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1426:1: ( ruleCurlyBracketedClauseCS EOF ) |
| // InternalEssentialOCL.g:1427:1: ruleCurlyBracketedClauseCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleCurlyBracketedClauseCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleCurlyBracketedClauseCS" |
| |
| |
| // $ANTLR start "ruleCurlyBracketedClauseCS" |
| // InternalEssentialOCL.g:1434:1: ruleCurlyBracketedClauseCS : ( ( rule__CurlyBracketedClauseCS__Group__0 ) ) ; |
| public final void ruleCurlyBracketedClauseCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1438:2: ( ( ( rule__CurlyBracketedClauseCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1439:1: ( ( rule__CurlyBracketedClauseCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1439:1: ( ( rule__CurlyBracketedClauseCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1440:1: ( rule__CurlyBracketedClauseCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1441:1: ( rule__CurlyBracketedClauseCS__Group__0 ) |
| // InternalEssentialOCL.g:1441:2: rule__CurlyBracketedClauseCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleCurlyBracketedClauseCS" |
| |
| |
| // $ANTLR start "entryRuleRoundBracketedClauseCS" |
| // InternalEssentialOCL.g:1453:1: entryRuleRoundBracketedClauseCS : ruleRoundBracketedClauseCS EOF ; |
| public final void entryRuleRoundBracketedClauseCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1454:1: ( ruleRoundBracketedClauseCS EOF ) |
| // InternalEssentialOCL.g:1455:1: ruleRoundBracketedClauseCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleRoundBracketedClauseCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleRoundBracketedClauseCS" |
| |
| |
| // $ANTLR start "ruleRoundBracketedClauseCS" |
| // InternalEssentialOCL.g:1462:1: ruleRoundBracketedClauseCS : ( ( rule__RoundBracketedClauseCS__Group__0 ) ) ; |
| public final void ruleRoundBracketedClauseCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1466:2: ( ( ( rule__RoundBracketedClauseCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1467:1: ( ( rule__RoundBracketedClauseCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1467:1: ( ( rule__RoundBracketedClauseCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1468:1: ( rule__RoundBracketedClauseCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1469:1: ( rule__RoundBracketedClauseCS__Group__0 ) |
| // InternalEssentialOCL.g:1469:2: rule__RoundBracketedClauseCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RoundBracketedClauseCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleRoundBracketedClauseCS" |
| |
| |
| // $ANTLR start "entryRuleSquareBracketedClauseCS" |
| // InternalEssentialOCL.g:1481:1: entryRuleSquareBracketedClauseCS : ruleSquareBracketedClauseCS EOF ; |
| public final void entryRuleSquareBracketedClauseCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1482:1: ( ruleSquareBracketedClauseCS EOF ) |
| // InternalEssentialOCL.g:1483:1: ruleSquareBracketedClauseCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSquareBracketedClauseCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleSquareBracketedClauseCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSquareBracketedClauseCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleSquareBracketedClauseCS" |
| |
| |
| // $ANTLR start "ruleSquareBracketedClauseCS" |
| // InternalEssentialOCL.g:1490:1: ruleSquareBracketedClauseCS : ( ( rule__SquareBracketedClauseCS__Group__0 ) ) ; |
| public final void ruleSquareBracketedClauseCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1494:2: ( ( ( rule__SquareBracketedClauseCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1495:1: ( ( rule__SquareBracketedClauseCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1495:1: ( ( rule__SquareBracketedClauseCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1496:1: ( rule__SquareBracketedClauseCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSquareBracketedClauseCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1497:1: ( rule__SquareBracketedClauseCS__Group__0 ) |
| // InternalEssentialOCL.g:1497:2: rule__SquareBracketedClauseCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SquareBracketedClauseCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSquareBracketedClauseCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleSquareBracketedClauseCS" |
| |
| |
| // $ANTLR start "entryRuleNavigatingArgCS" |
| // InternalEssentialOCL.g:1509:1: entryRuleNavigatingArgCS : ruleNavigatingArgCS EOF ; |
| public final void entryRuleNavigatingArgCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1510:1: ( ruleNavigatingArgCS EOF ) |
| // InternalEssentialOCL.g:1511:1: ruleNavigatingArgCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNavigatingArgCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNavigatingArgCS" |
| |
| |
| // $ANTLR start "ruleNavigatingArgCS" |
| // InternalEssentialOCL.g:1518:1: ruleNavigatingArgCS : ( ( rule__NavigatingArgCS__Alternatives ) ) ; |
| public final void ruleNavigatingArgCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1522:2: ( ( ( rule__NavigatingArgCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:1523:1: ( ( rule__NavigatingArgCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:1523:1: ( ( rule__NavigatingArgCS__Alternatives ) ) |
| // InternalEssentialOCL.g:1524:1: ( rule__NavigatingArgCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:1525:1: ( rule__NavigatingArgCS__Alternatives ) |
| // InternalEssentialOCL.g:1525:2: rule__NavigatingArgCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNavigatingArgCS" |
| |
| |
| // $ANTLR start "entryRuleNavigatingBarArgCS" |
| // InternalEssentialOCL.g:1537:1: entryRuleNavigatingBarArgCS : ruleNavigatingBarArgCS EOF ; |
| public final void entryRuleNavigatingBarArgCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1538:1: ( ruleNavigatingBarArgCS EOF ) |
| // InternalEssentialOCL.g:1539:1: ruleNavigatingBarArgCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNavigatingBarArgCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNavigatingBarArgCS" |
| |
| |
| // $ANTLR start "ruleNavigatingBarArgCS" |
| // InternalEssentialOCL.g:1546:1: ruleNavigatingBarArgCS : ( ( rule__NavigatingBarArgCS__Group__0 ) ) ; |
| public final void ruleNavigatingBarArgCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1550:2: ( ( ( rule__NavigatingBarArgCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1551:1: ( ( rule__NavigatingBarArgCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1551:1: ( ( rule__NavigatingBarArgCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1552:1: ( rule__NavigatingBarArgCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1553:1: ( rule__NavigatingBarArgCS__Group__0 ) |
| // InternalEssentialOCL.g:1553:2: rule__NavigatingBarArgCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNavigatingBarArgCS" |
| |
| |
| // $ANTLR start "entryRuleNavigatingCommaArgCS" |
| // InternalEssentialOCL.g:1565:1: entryRuleNavigatingCommaArgCS : ruleNavigatingCommaArgCS EOF ; |
| public final void entryRuleNavigatingCommaArgCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1566:1: ( ruleNavigatingCommaArgCS EOF ) |
| // InternalEssentialOCL.g:1567:1: ruleNavigatingCommaArgCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNavigatingCommaArgCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNavigatingCommaArgCS" |
| |
| |
| // $ANTLR start "ruleNavigatingCommaArgCS" |
| // InternalEssentialOCL.g:1574:1: ruleNavigatingCommaArgCS : ( ( rule__NavigatingCommaArgCS__Group__0 ) ) ; |
| public final void ruleNavigatingCommaArgCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1578:2: ( ( ( rule__NavigatingCommaArgCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1579:1: ( ( rule__NavigatingCommaArgCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1579:1: ( ( rule__NavigatingCommaArgCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1580:1: ( rule__NavigatingCommaArgCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1581:1: ( rule__NavigatingCommaArgCS__Group__0 ) |
| // InternalEssentialOCL.g:1581:2: rule__NavigatingCommaArgCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNavigatingCommaArgCS" |
| |
| |
| // $ANTLR start "entryRuleNavigatingSemiArgCS" |
| // InternalEssentialOCL.g:1593:1: entryRuleNavigatingSemiArgCS : ruleNavigatingSemiArgCS EOF ; |
| public final void entryRuleNavigatingSemiArgCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1594:1: ( ruleNavigatingSemiArgCS EOF ) |
| // InternalEssentialOCL.g:1595:1: ruleNavigatingSemiArgCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNavigatingSemiArgCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNavigatingSemiArgCS" |
| |
| |
| // $ANTLR start "ruleNavigatingSemiArgCS" |
| // InternalEssentialOCL.g:1602:1: ruleNavigatingSemiArgCS : ( ( rule__NavigatingSemiArgCS__Group__0 ) ) ; |
| public final void ruleNavigatingSemiArgCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1606:2: ( ( ( rule__NavigatingSemiArgCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1607:1: ( ( rule__NavigatingSemiArgCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1607:1: ( ( rule__NavigatingSemiArgCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1608:1: ( rule__NavigatingSemiArgCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1609:1: ( rule__NavigatingSemiArgCS__Group__0 ) |
| // InternalEssentialOCL.g:1609:2: rule__NavigatingSemiArgCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNavigatingSemiArgCS" |
| |
| |
| // $ANTLR start "entryRuleNavigatingArgExpCS" |
| // InternalEssentialOCL.g:1621:1: entryRuleNavigatingArgExpCS : ruleNavigatingArgExpCS EOF ; |
| public final void entryRuleNavigatingArgExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1622:1: ( ruleNavigatingArgExpCS EOF ) |
| // InternalEssentialOCL.g:1623:1: ruleNavigatingArgExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNavigatingArgExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNavigatingArgExpCS" |
| |
| |
| // $ANTLR start "ruleNavigatingArgExpCS" |
| // InternalEssentialOCL.g:1630:1: ruleNavigatingArgExpCS : ( ruleExpCS ) ; |
| public final void ruleNavigatingArgExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1634:2: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:1635:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:1635:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:1636:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgExpCSAccess().getExpCSParserRuleCall()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgExpCSAccess().getExpCSParserRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNavigatingArgExpCS" |
| |
| |
| // $ANTLR start "entryRuleCoIteratorVariableCS" |
| // InternalEssentialOCL.g:1649:1: entryRuleCoIteratorVariableCS : ruleCoIteratorVariableCS EOF ; |
| public final void entryRuleCoIteratorVariableCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1650:1: ( ruleCoIteratorVariableCS EOF ) |
| // InternalEssentialOCL.g:1651:1: ruleCoIteratorVariableCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCoIteratorVariableCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleCoIteratorVariableCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCoIteratorVariableCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleCoIteratorVariableCS" |
| |
| |
| // $ANTLR start "ruleCoIteratorVariableCS" |
| // InternalEssentialOCL.g:1658:1: ruleCoIteratorVariableCS : ( ( rule__CoIteratorVariableCS__Group__0 ) ) ; |
| public final void ruleCoIteratorVariableCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1662:2: ( ( ( rule__CoIteratorVariableCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1663:1: ( ( rule__CoIteratorVariableCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1663:1: ( ( rule__CoIteratorVariableCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1664:1: ( rule__CoIteratorVariableCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCoIteratorVariableCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1665:1: ( rule__CoIteratorVariableCS__Group__0 ) |
| // InternalEssentialOCL.g:1665:2: rule__CoIteratorVariableCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CoIteratorVariableCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCoIteratorVariableCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleCoIteratorVariableCS" |
| |
| |
| // $ANTLR start "entryRuleIfExpCS" |
| // InternalEssentialOCL.g:1677:1: entryRuleIfExpCS : ruleIfExpCS EOF ; |
| public final void entryRuleIfExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1678:1: ( ruleIfExpCS EOF ) |
| // InternalEssentialOCL.g:1679:1: ruleIfExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleIfExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleIfExpCS" |
| |
| |
| // $ANTLR start "ruleIfExpCS" |
| // InternalEssentialOCL.g:1686:1: ruleIfExpCS : ( ( rule__IfExpCS__Group__0 ) ) ; |
| public final void ruleIfExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1690:2: ( ( ( rule__IfExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1691:1: ( ( rule__IfExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1691:1: ( ( rule__IfExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1692:1: ( rule__IfExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1693:1: ( rule__IfExpCS__Group__0 ) |
| // InternalEssentialOCL.g:1693:2: rule__IfExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleIfExpCS" |
| |
| |
| // $ANTLR start "entryRuleElseIfThenExpCS" |
| // InternalEssentialOCL.g:1705:1: entryRuleElseIfThenExpCS : ruleElseIfThenExpCS EOF ; |
| public final void entryRuleElseIfThenExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1706:1: ( ruleElseIfThenExpCS EOF ) |
| // InternalEssentialOCL.g:1707:1: ruleElseIfThenExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getElseIfThenExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleElseIfThenExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getElseIfThenExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleElseIfThenExpCS" |
| |
| |
| // $ANTLR start "ruleElseIfThenExpCS" |
| // InternalEssentialOCL.g:1714:1: ruleElseIfThenExpCS : ( ( rule__ElseIfThenExpCS__Group__0 ) ) ; |
| public final void ruleElseIfThenExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1718:2: ( ( ( rule__ElseIfThenExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1719:1: ( ( rule__ElseIfThenExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1719:1: ( ( rule__ElseIfThenExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1720:1: ( rule__ElseIfThenExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getElseIfThenExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1721:1: ( rule__ElseIfThenExpCS__Group__0 ) |
| // InternalEssentialOCL.g:1721:2: rule__ElseIfThenExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ElseIfThenExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getElseIfThenExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleElseIfThenExpCS" |
| |
| |
| // $ANTLR start "entryRuleLetExpCS" |
| // InternalEssentialOCL.g:1733:1: entryRuleLetExpCS : ruleLetExpCS EOF ; |
| public final void entryRuleLetExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1734:1: ( ruleLetExpCS EOF ) |
| // InternalEssentialOCL.g:1735:1: ruleLetExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLetExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLetExpCS" |
| |
| |
| // $ANTLR start "ruleLetExpCS" |
| // InternalEssentialOCL.g:1742:1: ruleLetExpCS : ( ( rule__LetExpCS__Group__0 ) ) ; |
| public final void ruleLetExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1746:2: ( ( ( rule__LetExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1747:1: ( ( rule__LetExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1747:1: ( ( rule__LetExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1748:1: ( rule__LetExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1749:1: ( rule__LetExpCS__Group__0 ) |
| // InternalEssentialOCL.g:1749:2: rule__LetExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLetExpCS" |
| |
| |
| // $ANTLR start "entryRuleLetVariableCS" |
| // InternalEssentialOCL.g:1761:1: entryRuleLetVariableCS : ruleLetVariableCS EOF ; |
| public final void entryRuleLetVariableCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1762:1: ( ruleLetVariableCS EOF ) |
| // InternalEssentialOCL.g:1763:1: ruleLetVariableCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLetVariableCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLetVariableCS" |
| |
| |
| // $ANTLR start "ruleLetVariableCS" |
| // InternalEssentialOCL.g:1770:1: ruleLetVariableCS : ( ( rule__LetVariableCS__Group__0 ) ) ; |
| public final void ruleLetVariableCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1774:2: ( ( ( rule__LetVariableCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1775:1: ( ( rule__LetVariableCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1775:1: ( ( rule__LetVariableCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1776:1: ( rule__LetVariableCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1777:1: ( rule__LetVariableCS__Group__0 ) |
| // InternalEssentialOCL.g:1777:2: rule__LetVariableCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLetVariableCS" |
| |
| |
| // $ANTLR start "entryRuleNestedExpCS" |
| // InternalEssentialOCL.g:1789:1: entryRuleNestedExpCS : ruleNestedExpCS EOF ; |
| public final void entryRuleNestedExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1790:1: ( ruleNestedExpCS EOF ) |
| // InternalEssentialOCL.g:1791:1: ruleNestedExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNestedExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNestedExpCS" |
| |
| |
| // $ANTLR start "ruleNestedExpCS" |
| // InternalEssentialOCL.g:1798:1: ruleNestedExpCS : ( ( rule__NestedExpCS__Group__0 ) ) ; |
| public final void ruleNestedExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1802:2: ( ( ( rule__NestedExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1803:1: ( ( rule__NestedExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1803:1: ( ( rule__NestedExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1804:1: ( rule__NestedExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1805:1: ( rule__NestedExpCS__Group__0 ) |
| // InternalEssentialOCL.g:1805:2: rule__NestedExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NestedExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNestedExpCS" |
| |
| |
| // $ANTLR start "entryRuleSelfExpCS" |
| // InternalEssentialOCL.g:1817:1: entryRuleSelfExpCS : ruleSelfExpCS EOF ; |
| public final void entryRuleSelfExpCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1818:1: ( ruleSelfExpCS EOF ) |
| // InternalEssentialOCL.g:1819:1: ruleSelfExpCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSelfExpCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleSelfExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSelfExpCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleSelfExpCS" |
| |
| |
| // $ANTLR start "ruleSelfExpCS" |
| // InternalEssentialOCL.g:1826:1: ruleSelfExpCS : ( ( rule__SelfExpCS__Group__0 ) ) ; |
| public final void ruleSelfExpCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1830:2: ( ( ( rule__SelfExpCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1831:1: ( ( rule__SelfExpCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1831:1: ( ( rule__SelfExpCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1832:1: ( rule__SelfExpCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSelfExpCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1833:1: ( rule__SelfExpCS__Group__0 ) |
| // InternalEssentialOCL.g:1833:2: rule__SelfExpCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SelfExpCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSelfExpCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleSelfExpCS" |
| |
| |
| // $ANTLR start "entryRuleMultiplicityBoundsCS" |
| // InternalEssentialOCL.g:1845:1: entryRuleMultiplicityBoundsCS : ruleMultiplicityBoundsCS EOF ; |
| public final void entryRuleMultiplicityBoundsCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1846:1: ( ruleMultiplicityBoundsCS EOF ) |
| // InternalEssentialOCL.g:1847:1: ruleMultiplicityBoundsCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityBoundsCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleMultiplicityBoundsCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityBoundsCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleMultiplicityBoundsCS" |
| |
| |
| // $ANTLR start "ruleMultiplicityBoundsCS" |
| // InternalEssentialOCL.g:1854:1: ruleMultiplicityBoundsCS : ( ( rule__MultiplicityBoundsCS__Group__0 ) ) ; |
| public final void ruleMultiplicityBoundsCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1858:2: ( ( ( rule__MultiplicityBoundsCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1859:1: ( ( rule__MultiplicityBoundsCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1859:1: ( ( rule__MultiplicityBoundsCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1860:1: ( rule__MultiplicityBoundsCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityBoundsCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1861:1: ( rule__MultiplicityBoundsCS__Group__0 ) |
| // InternalEssentialOCL.g:1861:2: rule__MultiplicityBoundsCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityBoundsCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityBoundsCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleMultiplicityBoundsCS" |
| |
| |
| // $ANTLR start "entryRuleMultiplicityCS" |
| // InternalEssentialOCL.g:1873:1: entryRuleMultiplicityCS : ruleMultiplicityCS EOF ; |
| public final void entryRuleMultiplicityCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1874:1: ( ruleMultiplicityCS EOF ) |
| // InternalEssentialOCL.g:1875:1: ruleMultiplicityCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleMultiplicityCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleMultiplicityCS" |
| |
| |
| // $ANTLR start "ruleMultiplicityCS" |
| // InternalEssentialOCL.g:1882:1: ruleMultiplicityCS : ( ( rule__MultiplicityCS__Group__0 ) ) ; |
| public final void ruleMultiplicityCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1886:2: ( ( ( rule__MultiplicityCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1887:1: ( ( rule__MultiplicityCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1887:1: ( ( rule__MultiplicityCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1888:1: ( rule__MultiplicityCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1889:1: ( rule__MultiplicityCS__Group__0 ) |
| // InternalEssentialOCL.g:1889:2: rule__MultiplicityCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleMultiplicityCS" |
| |
| |
| // $ANTLR start "entryRuleMultiplicityStringCS" |
| // InternalEssentialOCL.g:1901:1: entryRuleMultiplicityStringCS : ruleMultiplicityStringCS EOF ; |
| public final void entryRuleMultiplicityStringCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1902:1: ( ruleMultiplicityStringCS EOF ) |
| // InternalEssentialOCL.g:1903:1: ruleMultiplicityStringCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityStringCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleMultiplicityStringCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityStringCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleMultiplicityStringCS" |
| |
| |
| // $ANTLR start "ruleMultiplicityStringCS" |
| // InternalEssentialOCL.g:1910:1: ruleMultiplicityStringCS : ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) ) ; |
| public final void ruleMultiplicityStringCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1914:2: ( ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) ) ) |
| // InternalEssentialOCL.g:1915:1: ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) ) |
| { |
| // InternalEssentialOCL.g:1915:1: ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) ) |
| // InternalEssentialOCL.g:1916:1: ( rule__MultiplicityStringCS__StringBoundsAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAssignment()); |
| } |
| // InternalEssentialOCL.g:1917:1: ( rule__MultiplicityStringCS__StringBoundsAssignment ) |
| // InternalEssentialOCL.g:1917:2: rule__MultiplicityStringCS__StringBoundsAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityStringCS__StringBoundsAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleMultiplicityStringCS" |
| |
| |
| // $ANTLR start "entryRulePathNameCS" |
| // InternalEssentialOCL.g:1929:1: entryRulePathNameCS : rulePathNameCS EOF ; |
| public final void entryRulePathNameCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1930:1: ( rulePathNameCS EOF ) |
| // InternalEssentialOCL.g:1931:1: rulePathNameCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPathNameCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| rulePathNameCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPathNameCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePathNameCS" |
| |
| |
| // $ANTLR start "rulePathNameCS" |
| // InternalEssentialOCL.g:1938:1: rulePathNameCS : ( ( rule__PathNameCS__Group__0 ) ) ; |
| public final void rulePathNameCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1942:2: ( ( ( rule__PathNameCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:1943:1: ( ( rule__PathNameCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:1943:1: ( ( rule__PathNameCS__Group__0 ) ) |
| // InternalEssentialOCL.g:1944:1: ( rule__PathNameCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPathNameCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:1945:1: ( rule__PathNameCS__Group__0 ) |
| // InternalEssentialOCL.g:1945:2: rule__PathNameCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PathNameCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPathNameCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePathNameCS" |
| |
| |
| // $ANTLR start "entryRuleFirstPathElementCS" |
| // InternalEssentialOCL.g:1959:1: entryRuleFirstPathElementCS : ruleFirstPathElementCS EOF ; |
| public final void entryRuleFirstPathElementCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1960:1: ( ruleFirstPathElementCS EOF ) |
| // InternalEssentialOCL.g:1961:1: ruleFirstPathElementCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getFirstPathElementCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleFirstPathElementCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getFirstPathElementCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleFirstPathElementCS" |
| |
| |
| // $ANTLR start "ruleFirstPathElementCS" |
| // InternalEssentialOCL.g:1968:1: ruleFirstPathElementCS : ( ( rule__FirstPathElementCS__ReferredElementAssignment ) ) ; |
| public final void ruleFirstPathElementCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:1972:2: ( ( ( rule__FirstPathElementCS__ReferredElementAssignment ) ) ) |
| // InternalEssentialOCL.g:1973:1: ( ( rule__FirstPathElementCS__ReferredElementAssignment ) ) |
| { |
| // InternalEssentialOCL.g:1973:1: ( ( rule__FirstPathElementCS__ReferredElementAssignment ) ) |
| // InternalEssentialOCL.g:1974:1: ( rule__FirstPathElementCS__ReferredElementAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getFirstPathElementCSAccess().getReferredElementAssignment()); |
| } |
| // InternalEssentialOCL.g:1975:1: ( rule__FirstPathElementCS__ReferredElementAssignment ) |
| // InternalEssentialOCL.g:1975:2: rule__FirstPathElementCS__ReferredElementAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__FirstPathElementCS__ReferredElementAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getFirstPathElementCSAccess().getReferredElementAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleFirstPathElementCS" |
| |
| |
| // $ANTLR start "entryRuleNextPathElementCS" |
| // InternalEssentialOCL.g:1987:1: entryRuleNextPathElementCS : ruleNextPathElementCS EOF ; |
| public final void entryRuleNextPathElementCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:1988:1: ( ruleNextPathElementCS EOF ) |
| // InternalEssentialOCL.g:1989:1: ruleNextPathElementCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNextPathElementCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNextPathElementCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNextPathElementCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNextPathElementCS" |
| |
| |
| // $ANTLR start "ruleNextPathElementCS" |
| // InternalEssentialOCL.g:1996:1: ruleNextPathElementCS : ( ( rule__NextPathElementCS__ReferredElementAssignment ) ) ; |
| public final void ruleNextPathElementCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2000:2: ( ( ( rule__NextPathElementCS__ReferredElementAssignment ) ) ) |
| // InternalEssentialOCL.g:2001:1: ( ( rule__NextPathElementCS__ReferredElementAssignment ) ) |
| { |
| // InternalEssentialOCL.g:2001:1: ( ( rule__NextPathElementCS__ReferredElementAssignment ) ) |
| // InternalEssentialOCL.g:2002:1: ( rule__NextPathElementCS__ReferredElementAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNextPathElementCSAccess().getReferredElementAssignment()); |
| } |
| // InternalEssentialOCL.g:2003:1: ( rule__NextPathElementCS__ReferredElementAssignment ) |
| // InternalEssentialOCL.g:2003:2: rule__NextPathElementCS__ReferredElementAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NextPathElementCS__ReferredElementAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNextPathElementCSAccess().getReferredElementAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNextPathElementCS" |
| |
| |
| // $ANTLR start "entryRuleTemplateBindingCS" |
| // InternalEssentialOCL.g:2015:1: entryRuleTemplateBindingCS : ruleTemplateBindingCS EOF ; |
| public final void entryRuleTemplateBindingCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2016:1: ( ruleTemplateBindingCS EOF ) |
| // InternalEssentialOCL.g:2017:1: ruleTemplateBindingCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateBindingCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTemplateBindingCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateBindingCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTemplateBindingCS" |
| |
| |
| // $ANTLR start "ruleTemplateBindingCS" |
| // InternalEssentialOCL.g:2024:1: ruleTemplateBindingCS : ( ( rule__TemplateBindingCS__Group__0 ) ) ; |
| public final void ruleTemplateBindingCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2028:2: ( ( ( rule__TemplateBindingCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:2029:1: ( ( rule__TemplateBindingCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:2029:1: ( ( rule__TemplateBindingCS__Group__0 ) ) |
| // InternalEssentialOCL.g:2030:1: ( rule__TemplateBindingCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateBindingCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:2031:1: ( rule__TemplateBindingCS__Group__0 ) |
| // InternalEssentialOCL.g:2031:2: rule__TemplateBindingCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TemplateBindingCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateBindingCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTemplateBindingCS" |
| |
| |
| // $ANTLR start "entryRuleTemplateParameterSubstitutionCS" |
| // InternalEssentialOCL.g:2043:1: entryRuleTemplateParameterSubstitutionCS : ruleTemplateParameterSubstitutionCS EOF ; |
| public final void entryRuleTemplateParameterSubstitutionCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2044:1: ( ruleTemplateParameterSubstitutionCS EOF ) |
| // InternalEssentialOCL.g:2045:1: ruleTemplateParameterSubstitutionCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateParameterSubstitutionCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTemplateParameterSubstitutionCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateParameterSubstitutionCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTemplateParameterSubstitutionCS" |
| |
| |
| // $ANTLR start "ruleTemplateParameterSubstitutionCS" |
| // InternalEssentialOCL.g:2052:1: ruleTemplateParameterSubstitutionCS : ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) ) ; |
| public final void ruleTemplateParameterSubstitutionCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2056:2: ( ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) ) ) |
| // InternalEssentialOCL.g:2057:1: ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) ) |
| { |
| // InternalEssentialOCL.g:2057:1: ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) ) |
| // InternalEssentialOCL.g:2058:1: ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterAssignment()); |
| } |
| // InternalEssentialOCL.g:2059:1: ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) |
| // InternalEssentialOCL.g:2059:2: rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterAssignment()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTemplateParameterSubstitutionCS" |
| |
| |
| // $ANTLR start "entryRuleTypeParameterCS" |
| // InternalEssentialOCL.g:2073:1: entryRuleTypeParameterCS : ruleTypeParameterCS EOF ; |
| public final void entryRuleTypeParameterCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2074:1: ( ruleTypeParameterCS EOF ) |
| // InternalEssentialOCL.g:2075:1: ruleTypeParameterCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTypeParameterCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTypeParameterCS" |
| |
| |
| // $ANTLR start "ruleTypeParameterCS" |
| // InternalEssentialOCL.g:2082:1: ruleTypeParameterCS : ( ( rule__TypeParameterCS__Group__0 ) ) ; |
| public final void ruleTypeParameterCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2086:2: ( ( ( rule__TypeParameterCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:2087:1: ( ( rule__TypeParameterCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:2087:1: ( ( rule__TypeParameterCS__Group__0 ) ) |
| // InternalEssentialOCL.g:2088:1: ( rule__TypeParameterCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:2089:1: ( rule__TypeParameterCS__Group__0 ) |
| // InternalEssentialOCL.g:2089:2: rule__TypeParameterCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTypeParameterCS" |
| |
| |
| // $ANTLR start "entryRuleTypeRefCS" |
| // InternalEssentialOCL.g:2101:1: entryRuleTypeRefCS : ruleTypeRefCS EOF ; |
| public final void entryRuleTypeRefCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2102:1: ( ruleTypeRefCS EOF ) |
| // InternalEssentialOCL.g:2103:1: ruleTypeRefCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeRefCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTypeRefCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeRefCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTypeRefCS" |
| |
| |
| // $ANTLR start "ruleTypeRefCS" |
| // InternalEssentialOCL.g:2110:1: ruleTypeRefCS : ( ( rule__TypeRefCS__Alternatives ) ) ; |
| public final void ruleTypeRefCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2114:2: ( ( ( rule__TypeRefCS__Alternatives ) ) ) |
| // InternalEssentialOCL.g:2115:1: ( ( rule__TypeRefCS__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:2115:1: ( ( rule__TypeRefCS__Alternatives ) ) |
| // InternalEssentialOCL.g:2116:1: ( rule__TypeRefCS__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeRefCSAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:2117:1: ( rule__TypeRefCS__Alternatives ) |
| // InternalEssentialOCL.g:2117:2: rule__TypeRefCS__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeRefCS__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeRefCSAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTypeRefCS" |
| |
| |
| // $ANTLR start "entryRuleTypedRefCS" |
| // InternalEssentialOCL.g:2129:1: entryRuleTypedRefCS : ruleTypedRefCS EOF ; |
| public final void entryRuleTypedRefCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2130:1: ( ruleTypedRefCS EOF ) |
| // InternalEssentialOCL.g:2131:1: ruleTypedRefCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypedRefCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTypedRefCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypedRefCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTypedRefCS" |
| |
| |
| // $ANTLR start "ruleTypedRefCS" |
| // InternalEssentialOCL.g:2138:1: ruleTypedRefCS : ( ruleTypedTypeRefCS ) ; |
| public final void ruleTypedRefCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2142:2: ( ( ruleTypedTypeRefCS ) ) |
| // InternalEssentialOCL.g:2143:1: ( ruleTypedTypeRefCS ) |
| { |
| // InternalEssentialOCL.g:2143:1: ( ruleTypedTypeRefCS ) |
| // InternalEssentialOCL.g:2144:1: ruleTypedTypeRefCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypedRefCSAccess().getTypedTypeRefCSParserRuleCall()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypedTypeRefCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypedRefCSAccess().getTypedTypeRefCSParserRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTypedRefCS" |
| |
| |
| // $ANTLR start "entryRuleTypedTypeRefCS" |
| // InternalEssentialOCL.g:2157:1: entryRuleTypedTypeRefCS : ruleTypedTypeRefCS EOF ; |
| public final void entryRuleTypedTypeRefCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2158:1: ( ruleTypedTypeRefCS EOF ) |
| // InternalEssentialOCL.g:2159:1: ruleTypedTypeRefCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypedTypeRefCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleTypedTypeRefCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypedTypeRefCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTypedTypeRefCS" |
| |
| |
| // $ANTLR start "ruleTypedTypeRefCS" |
| // InternalEssentialOCL.g:2166:1: ruleTypedTypeRefCS : ( ( rule__TypedTypeRefCS__Group__0 ) ) ; |
| public final void ruleTypedTypeRefCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2170:2: ( ( ( rule__TypedTypeRefCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:2171:1: ( ( rule__TypedTypeRefCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:2171:1: ( ( rule__TypedTypeRefCS__Group__0 ) ) |
| // InternalEssentialOCL.g:2172:1: ( rule__TypedTypeRefCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypedTypeRefCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:2173:1: ( rule__TypedTypeRefCS__Group__0 ) |
| // InternalEssentialOCL.g:2173:2: rule__TypedTypeRefCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypedTypeRefCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypedTypeRefCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTypedTypeRefCS" |
| |
| |
| // $ANTLR start "entryRuleWildcardTypeRefCS" |
| // InternalEssentialOCL.g:2185:1: entryRuleWildcardTypeRefCS : ruleWildcardTypeRefCS EOF ; |
| public final void entryRuleWildcardTypeRefCS() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2186:1: ( ruleWildcardTypeRefCS EOF ) |
| // InternalEssentialOCL.g:2187:1: ruleWildcardTypeRefCS EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWildcardTypeRefCSRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleWildcardTypeRefCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWildcardTypeRefCSRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleWildcardTypeRefCS" |
| |
| |
| // $ANTLR start "ruleWildcardTypeRefCS" |
| // InternalEssentialOCL.g:2194:1: ruleWildcardTypeRefCS : ( ( rule__WildcardTypeRefCS__Group__0 ) ) ; |
| public final void ruleWildcardTypeRefCS() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2198:2: ( ( ( rule__WildcardTypeRefCS__Group__0 ) ) ) |
| // InternalEssentialOCL.g:2199:1: ( ( rule__WildcardTypeRefCS__Group__0 ) ) |
| { |
| // InternalEssentialOCL.g:2199:1: ( ( rule__WildcardTypeRefCS__Group__0 ) ) |
| // InternalEssentialOCL.g:2200:1: ( rule__WildcardTypeRefCS__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWildcardTypeRefCSAccess().getGroup()); |
| } |
| // InternalEssentialOCL.g:2201:1: ( rule__WildcardTypeRefCS__Group__0 ) |
| // InternalEssentialOCL.g:2201:2: rule__WildcardTypeRefCS__Group__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__WildcardTypeRefCS__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWildcardTypeRefCSAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleWildcardTypeRefCS" |
| |
| |
| // $ANTLR start "entryRuleID" |
| // InternalEssentialOCL.g:2213:1: entryRuleID : ruleID EOF ; |
| public final void entryRuleID() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2214:1: ( ruleID EOF ) |
| // InternalEssentialOCL.g:2215:1: ruleID EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIDRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIDRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleID" |
| |
| |
| // $ANTLR start "ruleID" |
| // InternalEssentialOCL.g:2222:1: ruleID : ( ( rule__ID__Alternatives ) ) ; |
| public final void ruleID() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2226:2: ( ( ( rule__ID__Alternatives ) ) ) |
| // InternalEssentialOCL.g:2227:1: ( ( rule__ID__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:2227:1: ( ( rule__ID__Alternatives ) ) |
| // InternalEssentialOCL.g:2228:1: ( rule__ID__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIDAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:2229:1: ( rule__ID__Alternatives ) |
| // InternalEssentialOCL.g:2229:2: rule__ID__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ID__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIDAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleID" |
| |
| |
| // $ANTLR start "entryRuleIdentifier" |
| // InternalEssentialOCL.g:2241:1: entryRuleIdentifier : ruleIdentifier EOF ; |
| public final void entryRuleIdentifier() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2242:1: ( ruleIdentifier EOF ) |
| // InternalEssentialOCL.g:2243:1: ruleIdentifier EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIdentifierRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleIdentifier(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIdentifierRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleIdentifier" |
| |
| |
| // $ANTLR start "ruleIdentifier" |
| // InternalEssentialOCL.g:2250:1: ruleIdentifier : ( ruleID ) ; |
| public final void ruleIdentifier() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2254:2: ( ( ruleID ) ) |
| // InternalEssentialOCL.g:2255:1: ( ruleID ) |
| { |
| // InternalEssentialOCL.g:2255:1: ( ruleID ) |
| // InternalEssentialOCL.g:2256:1: ruleID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIdentifierAccess().getIDParserRuleCall()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIdentifierAccess().getIDParserRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleIdentifier" |
| |
| |
| // $ANTLR start "entryRuleLOWER" |
| // InternalEssentialOCL.g:2269:1: entryRuleLOWER : ruleLOWER EOF ; |
| public final void entryRuleLOWER() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2270:1: ( ruleLOWER EOF ) |
| // InternalEssentialOCL.g:2271:1: ruleLOWER EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLOWERRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleLOWER(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLOWERRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLOWER" |
| |
| |
| // $ANTLR start "ruleLOWER" |
| // InternalEssentialOCL.g:2278:1: ruleLOWER : ( RULE_INT ) ; |
| public final void ruleLOWER() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2282:2: ( ( RULE_INT ) ) |
| // InternalEssentialOCL.g:2283:1: ( RULE_INT ) |
| { |
| // InternalEssentialOCL.g:2283:1: ( RULE_INT ) |
| // InternalEssentialOCL.g:2284:1: RULE_INT |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLOWERAccess().getINTTerminalRuleCall()); |
| } |
| match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLOWERAccess().getINTTerminalRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLOWER" |
| |
| |
| // $ANTLR start "entryRuleNUMBER_LITERAL" |
| // InternalEssentialOCL.g:2297:1: entryRuleNUMBER_LITERAL : ruleNUMBER_LITERAL EOF ; |
| public final void entryRuleNUMBER_LITERAL() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2298:1: ( ruleNUMBER_LITERAL EOF ) |
| // InternalEssentialOCL.g:2299:1: ruleNUMBER_LITERAL EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNUMBER_LITERALRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleNUMBER_LITERAL(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNUMBER_LITERALRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNUMBER_LITERAL" |
| |
| |
| // $ANTLR start "ruleNUMBER_LITERAL" |
| // InternalEssentialOCL.g:2306:1: ruleNUMBER_LITERAL : ( RULE_INT ) ; |
| public final void ruleNUMBER_LITERAL() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2310:2: ( ( RULE_INT ) ) |
| // InternalEssentialOCL.g:2311:1: ( RULE_INT ) |
| { |
| // InternalEssentialOCL.g:2311:1: ( RULE_INT ) |
| // InternalEssentialOCL.g:2312:1: RULE_INT |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNUMBER_LITERALAccess().getINTTerminalRuleCall()); |
| } |
| match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNUMBER_LITERALAccess().getINTTerminalRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNUMBER_LITERAL" |
| |
| |
| // $ANTLR start "entryRuleStringLiteral" |
| // InternalEssentialOCL.g:2325:1: entryRuleStringLiteral : ruleStringLiteral EOF ; |
| public final void entryRuleStringLiteral() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2326:1: ( ruleStringLiteral EOF ) |
| // InternalEssentialOCL.g:2327:1: ruleStringLiteral EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringLiteralRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleStringLiteral(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringLiteralRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleStringLiteral" |
| |
| |
| // $ANTLR start "ruleStringLiteral" |
| // InternalEssentialOCL.g:2334:1: ruleStringLiteral : ( RULE_SINGLE_QUOTED_STRING ) ; |
| public final void ruleStringLiteral() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2338:2: ( ( RULE_SINGLE_QUOTED_STRING ) ) |
| // InternalEssentialOCL.g:2339:1: ( RULE_SINGLE_QUOTED_STRING ) |
| { |
| // InternalEssentialOCL.g:2339:1: ( RULE_SINGLE_QUOTED_STRING ) |
| // InternalEssentialOCL.g:2340:1: RULE_SINGLE_QUOTED_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringLiteralAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall()); |
| } |
| match(input,RULE_SINGLE_QUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringLiteralAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleStringLiteral" |
| |
| |
| // $ANTLR start "entryRuleUPPER" |
| // InternalEssentialOCL.g:2353:1: entryRuleUPPER : ruleUPPER EOF ; |
| public final void entryRuleUPPER() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2354:1: ( ruleUPPER EOF ) |
| // InternalEssentialOCL.g:2355:1: ruleUPPER EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUPPERRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleUPPER(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUPPERRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleUPPER" |
| |
| |
| // $ANTLR start "ruleUPPER" |
| // InternalEssentialOCL.g:2362:1: ruleUPPER : ( ( rule__UPPER__Alternatives ) ) ; |
| public final void ruleUPPER() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2366:2: ( ( ( rule__UPPER__Alternatives ) ) ) |
| // InternalEssentialOCL.g:2367:1: ( ( rule__UPPER__Alternatives ) ) |
| { |
| // InternalEssentialOCL.g:2367:1: ( ( rule__UPPER__Alternatives ) ) |
| // InternalEssentialOCL.g:2368:1: ( rule__UPPER__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUPPERAccess().getAlternatives()); |
| } |
| // InternalEssentialOCL.g:2369:1: ( rule__UPPER__Alternatives ) |
| // InternalEssentialOCL.g:2369:2: rule__UPPER__Alternatives |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__UPPER__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUPPERAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleUPPER" |
| |
| |
| // $ANTLR start "entryRuleURI" |
| // InternalEssentialOCL.g:2381:1: entryRuleURI : ruleURI EOF ; |
| public final void entryRuleURI() throws RecognitionException { |
| try { |
| // InternalEssentialOCL.g:2382:1: ( ruleURI EOF ) |
| // InternalEssentialOCL.g:2383:1: ruleURI EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIRule()); |
| } |
| pushFollow(FollowSets000.FOLLOW_1); |
| ruleURI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIRule()); |
| } |
| match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleURI" |
| |
| |
| // $ANTLR start "ruleURI" |
| // InternalEssentialOCL.g:2390:1: ruleURI : ( RULE_SINGLE_QUOTED_STRING ) ; |
| public final void ruleURI() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2394:2: ( ( RULE_SINGLE_QUOTED_STRING ) ) |
| // InternalEssentialOCL.g:2395:1: ( RULE_SINGLE_QUOTED_STRING ) |
| { |
| // InternalEssentialOCL.g:2395:1: ( RULE_SINGLE_QUOTED_STRING ) |
| // InternalEssentialOCL.g:2396:1: RULE_SINGLE_QUOTED_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall()); |
| } |
| match(input,RULE_SINGLE_QUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleURI" |
| |
| |
| // $ANTLR start "rule__EssentialOCLUnaryOperatorName__Alternatives" |
| // InternalEssentialOCL.g:2410:1: rule__EssentialOCLUnaryOperatorName__Alternatives : ( ( '-' ) | ( 'not' ) | ( 'not2' ) ); |
| public final void rule__EssentialOCLUnaryOperatorName__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2414:1: ( ( '-' ) | ( 'not' ) | ( 'not2' ) ) |
| int alt2=3; |
| switch ( input.LA(1) ) { |
| case 16: |
| { |
| alt2=1; |
| } |
| break; |
| case 17: |
| { |
| alt2=2; |
| } |
| break; |
| case 18: |
| { |
| alt2=3; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 2, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt2) { |
| case 1 : |
| // InternalEssentialOCL.g:2415:1: ( '-' ) |
| { |
| // InternalEssentialOCL.g:2415:1: ( '-' ) |
| // InternalEssentialOCL.g:2416:1: '-' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getHyphenMinusKeyword_0()); |
| } |
| match(input,16,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getHyphenMinusKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2423:6: ( 'not' ) |
| { |
| // InternalEssentialOCL.g:2423:6: ( 'not' ) |
| // InternalEssentialOCL.g:2424:1: 'not' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNotKeyword_1()); |
| } |
| match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNotKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:2431:6: ( 'not2' ) |
| { |
| // InternalEssentialOCL.g:2431:6: ( 'not2' ) |
| // InternalEssentialOCL.g:2432:1: 'not2' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNot2Keyword_2()); |
| } |
| match(input,18,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNot2Keyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EssentialOCLUnaryOperatorName__Alternatives" |
| |
| |
| // $ANTLR start "rule__EssentialOCLInfixOperatorName__Alternatives" |
| // InternalEssentialOCL.g:2444:1: rule__EssentialOCLInfixOperatorName__Alternatives : ( ( '*' ) | ( '/' ) | ( '+' ) | ( '-' ) | ( '>' ) | ( '<' ) | ( '>=' ) | ( '<=' ) | ( '=' ) | ( '<>' ) | ( 'and' ) | ( 'and2' ) | ( 'implies' ) | ( 'implies2' ) | ( 'or' ) | ( 'or2' ) | ( 'xor' ) | ( 'xor2' ) ); |
| public final void rule__EssentialOCLInfixOperatorName__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2448:1: ( ( '*' ) | ( '/' ) | ( '+' ) | ( '-' ) | ( '>' ) | ( '<' ) | ( '>=' ) | ( '<=' ) | ( '=' ) | ( '<>' ) | ( 'and' ) | ( 'and2' ) | ( 'implies' ) | ( 'implies2' ) | ( 'or' ) | ( 'or2' ) | ( 'xor' ) | ( 'xor2' ) ) |
| int alt3=18; |
| switch ( input.LA(1) ) { |
| case 19: |
| { |
| alt3=1; |
| } |
| break; |
| case 20: |
| { |
| alt3=2; |
| } |
| break; |
| case 21: |
| { |
| alt3=3; |
| } |
| break; |
| case 16: |
| { |
| alt3=4; |
| } |
| break; |
| case 22: |
| { |
| alt3=5; |
| } |
| break; |
| case 23: |
| { |
| alt3=6; |
| } |
| break; |
| case 24: |
| { |
| alt3=7; |
| } |
| break; |
| case 25: |
| { |
| alt3=8; |
| } |
| break; |
| case 26: |
| { |
| alt3=9; |
| } |
| break; |
| case 27: |
| { |
| alt3=10; |
| } |
| break; |
| case 28: |
| { |
| alt3=11; |
| } |
| break; |
| case 29: |
| { |
| alt3=12; |
| } |
| break; |
| case 30: |
| { |
| alt3=13; |
| } |
| break; |
| case 31: |
| { |
| alt3=14; |
| } |
| break; |
| case 32: |
| { |
| alt3=15; |
| } |
| break; |
| case 33: |
| { |
| alt3=16; |
| } |
| break; |
| case 34: |
| { |
| alt3=17; |
| } |
| break; |
| case 35: |
| { |
| alt3=18; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 3, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt3) { |
| case 1 : |
| // InternalEssentialOCL.g:2449:1: ( '*' ) |
| { |
| // InternalEssentialOCL.g:2449:1: ( '*' ) |
| // InternalEssentialOCL.g:2450:1: '*' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAsteriskKeyword_0()); |
| } |
| match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAsteriskKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2457:6: ( '/' ) |
| { |
| // InternalEssentialOCL.g:2457:6: ( '/' ) |
| // InternalEssentialOCL.g:2458:1: '/' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getSolidusKeyword_1()); |
| } |
| match(input,20,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getSolidusKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:2465:6: ( '+' ) |
| { |
| // InternalEssentialOCL.g:2465:6: ( '+' ) |
| // InternalEssentialOCL.g:2466:1: '+' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getPlusSignKeyword_2()); |
| } |
| match(input,21,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getPlusSignKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalEssentialOCL.g:2473:6: ( '-' ) |
| { |
| // InternalEssentialOCL.g:2473:6: ( '-' ) |
| // InternalEssentialOCL.g:2474:1: '-' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getHyphenMinusKeyword_3()); |
| } |
| match(input,16,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getHyphenMinusKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalEssentialOCL.g:2481:6: ( '>' ) |
| { |
| // InternalEssentialOCL.g:2481:6: ( '>' ) |
| // InternalEssentialOCL.g:2482:1: '>' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignKeyword_4()); |
| } |
| match(input,22,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 6 : |
| // InternalEssentialOCL.g:2489:6: ( '<' ) |
| { |
| // InternalEssentialOCL.g:2489:6: ( '<' ) |
| // InternalEssentialOCL.g:2490:1: '<' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignKeyword_5()); |
| } |
| match(input,23,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignKeyword_5()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 7 : |
| // InternalEssentialOCL.g:2497:6: ( '>=' ) |
| { |
| // InternalEssentialOCL.g:2497:6: ( '>=' ) |
| // InternalEssentialOCL.g:2498:1: '>=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignEqualsSignKeyword_6()); |
| } |
| match(input,24,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignEqualsSignKeyword_6()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 8 : |
| // InternalEssentialOCL.g:2505:6: ( '<=' ) |
| { |
| // InternalEssentialOCL.g:2505:6: ( '<=' ) |
| // InternalEssentialOCL.g:2506:1: '<=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignEqualsSignKeyword_7()); |
| } |
| match(input,25,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignEqualsSignKeyword_7()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 9 : |
| // InternalEssentialOCL.g:2513:6: ( '=' ) |
| { |
| // InternalEssentialOCL.g:2513:6: ( '=' ) |
| // InternalEssentialOCL.g:2514:1: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getEqualsSignKeyword_8()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getEqualsSignKeyword_8()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 10 : |
| // InternalEssentialOCL.g:2521:6: ( '<>' ) |
| { |
| // InternalEssentialOCL.g:2521:6: ( '<>' ) |
| // InternalEssentialOCL.g:2522:1: '<>' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignGreaterThanSignKeyword_9()); |
| } |
| match(input,27,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignGreaterThanSignKeyword_9()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 11 : |
| // InternalEssentialOCL.g:2529:6: ( 'and' ) |
| { |
| // InternalEssentialOCL.g:2529:6: ( 'and' ) |
| // InternalEssentialOCL.g:2530:1: 'and' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAndKeyword_10()); |
| } |
| match(input,28,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAndKeyword_10()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 12 : |
| // InternalEssentialOCL.g:2537:6: ( 'and2' ) |
| { |
| // InternalEssentialOCL.g:2537:6: ( 'and2' ) |
| // InternalEssentialOCL.g:2538:1: 'and2' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAnd2Keyword_11()); |
| } |
| match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAnd2Keyword_11()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 13 : |
| // InternalEssentialOCL.g:2545:6: ( 'implies' ) |
| { |
| // InternalEssentialOCL.g:2545:6: ( 'implies' ) |
| // InternalEssentialOCL.g:2546:1: 'implies' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImpliesKeyword_12()); |
| } |
| match(input,30,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImpliesKeyword_12()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 14 : |
| // InternalEssentialOCL.g:2553:6: ( 'implies2' ) |
| { |
| // InternalEssentialOCL.g:2553:6: ( 'implies2' ) |
| // InternalEssentialOCL.g:2554:1: 'implies2' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImplies2Keyword_13()); |
| } |
| match(input,31,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImplies2Keyword_13()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 15 : |
| // InternalEssentialOCL.g:2561:6: ( 'or' ) |
| { |
| // InternalEssentialOCL.g:2561:6: ( 'or' ) |
| // InternalEssentialOCL.g:2562:1: 'or' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOrKeyword_14()); |
| } |
| match(input,32,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOrKeyword_14()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 16 : |
| // InternalEssentialOCL.g:2569:6: ( 'or2' ) |
| { |
| // InternalEssentialOCL.g:2569:6: ( 'or2' ) |
| // InternalEssentialOCL.g:2570:1: 'or2' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOr2Keyword_15()); |
| } |
| match(input,33,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOr2Keyword_15()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 17 : |
| // InternalEssentialOCL.g:2577:6: ( 'xor' ) |
| { |
| // InternalEssentialOCL.g:2577:6: ( 'xor' ) |
| // InternalEssentialOCL.g:2578:1: 'xor' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXorKeyword_16()); |
| } |
| match(input,34,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXorKeyword_16()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 18 : |
| // InternalEssentialOCL.g:2585:6: ( 'xor2' ) |
| { |
| // InternalEssentialOCL.g:2585:6: ( 'xor2' ) |
| // InternalEssentialOCL.g:2586:1: 'xor2' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXor2Keyword_17()); |
| } |
| match(input,35,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXor2Keyword_17()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EssentialOCLInfixOperatorName__Alternatives" |
| |
| |
| // $ANTLR start "rule__EssentialOCLNavigationOperatorName__Alternatives" |
| // InternalEssentialOCL.g:2598:1: rule__EssentialOCLNavigationOperatorName__Alternatives : ( ( '.' ) | ( '->' ) | ( '?.' ) | ( '?->' ) ); |
| public final void rule__EssentialOCLNavigationOperatorName__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2602:1: ( ( '.' ) | ( '->' ) | ( '?.' ) | ( '?->' ) ) |
| int alt4=4; |
| switch ( input.LA(1) ) { |
| case 36: |
| { |
| alt4=1; |
| } |
| break; |
| case 37: |
| { |
| alt4=2; |
| } |
| break; |
| case 38: |
| { |
| alt4=3; |
| } |
| break; |
| case 39: |
| { |
| alt4=4; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 4, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt4) { |
| case 1 : |
| // InternalEssentialOCL.g:2603:1: ( '.' ) |
| { |
| // InternalEssentialOCL.g:2603:1: ( '.' ) |
| // InternalEssentialOCL.g:2604:1: '.' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getFullStopKeyword_0()); |
| } |
| match(input,36,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getFullStopKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2611:6: ( '->' ) |
| { |
| // InternalEssentialOCL.g:2611:6: ( '->' ) |
| // InternalEssentialOCL.g:2612:1: '->' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getHyphenMinusGreaterThanSignKeyword_1()); |
| } |
| match(input,37,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getHyphenMinusGreaterThanSignKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:2619:6: ( '?.' ) |
| { |
| // InternalEssentialOCL.g:2619:6: ( '?.' ) |
| // InternalEssentialOCL.g:2620:1: '?.' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkFullStopKeyword_2()); |
| } |
| match(input,38,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkFullStopKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalEssentialOCL.g:2627:6: ( '?->' ) |
| { |
| // InternalEssentialOCL.g:2627:6: ( '?->' ) |
| // InternalEssentialOCL.g:2628:1: '?->' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkHyphenMinusGreaterThanSignKeyword_3()); |
| } |
| match(input,39,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkHyphenMinusGreaterThanSignKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EssentialOCLNavigationOperatorName__Alternatives" |
| |
| |
| // $ANTLR start "rule__BinaryOperatorName__Alternatives" |
| // InternalEssentialOCL.g:2640:1: rule__BinaryOperatorName__Alternatives : ( ( ruleInfixOperatorName ) | ( ruleNavigationOperatorName ) ); |
| public final void rule__BinaryOperatorName__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2644:1: ( ( ruleInfixOperatorName ) | ( ruleNavigationOperatorName ) ) |
| int alt5=2; |
| int LA5_0 = input.LA(1); |
| |
| if ( (LA5_0==16||(LA5_0>=19 && LA5_0<=35)) ) { |
| alt5=1; |
| } |
| else if ( ((LA5_0>=36 && LA5_0<=39)) ) { |
| alt5=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 5, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt5) { |
| case 1 : |
| // InternalEssentialOCL.g:2645:1: ( ruleInfixOperatorName ) |
| { |
| // InternalEssentialOCL.g:2645:1: ( ruleInfixOperatorName ) |
| // InternalEssentialOCL.g:2646:1: ruleInfixOperatorName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBinaryOperatorNameAccess().getInfixOperatorNameParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleInfixOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBinaryOperatorNameAccess().getInfixOperatorNameParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2651:6: ( ruleNavigationOperatorName ) |
| { |
| // InternalEssentialOCL.g:2651:6: ( ruleNavigationOperatorName ) |
| // InternalEssentialOCL.g:2652:1: ruleNavigationOperatorName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBinaryOperatorNameAccess().getNavigationOperatorNameParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNavigationOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBinaryOperatorNameAccess().getNavigationOperatorNameParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__BinaryOperatorName__Alternatives" |
| |
| |
| // $ANTLR start "rule__EssentialOCLUnreservedName__Alternatives" |
| // InternalEssentialOCL.g:2662:1: rule__EssentialOCLUnreservedName__Alternatives : ( ( ruleUnrestrictedName ) | ( ruleCollectionTypeIdentifier ) | ( rulePrimitiveTypeIdentifier ) | ( 'Map' ) | ( 'Tuple' ) ); |
| public final void rule__EssentialOCLUnreservedName__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2666:1: ( ( ruleUnrestrictedName ) | ( ruleCollectionTypeIdentifier ) | ( rulePrimitiveTypeIdentifier ) | ( 'Map' ) | ( 'Tuple' ) ) |
| int alt6=5; |
| switch ( input.LA(1) ) { |
| case RULE_SIMPLE_ID: |
| case RULE_ESCAPED_ID: |
| { |
| alt6=1; |
| } |
| break; |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| { |
| alt6=2; |
| } |
| break; |
| case 42: |
| case 43: |
| case 44: |
| case 45: |
| case 46: |
| case 47: |
| case 48: |
| case 49: |
| { |
| alt6=3; |
| } |
| break; |
| case 40: |
| { |
| alt6=4; |
| } |
| break; |
| case 41: |
| { |
| alt6=5; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 6, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt6) { |
| case 1 : |
| // InternalEssentialOCL.g:2667:1: ( ruleUnrestrictedName ) |
| { |
| // InternalEssentialOCL.g:2667:1: ( ruleUnrestrictedName ) |
| // InternalEssentialOCL.g:2668:1: ruleUnrestrictedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnreservedNameAccess().getUnrestrictedNameParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnreservedNameAccess().getUnrestrictedNameParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2673:6: ( ruleCollectionTypeIdentifier ) |
| { |
| // InternalEssentialOCL.g:2673:6: ( ruleCollectionTypeIdentifier ) |
| // InternalEssentialOCL.g:2674:1: ruleCollectionTypeIdentifier |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnreservedNameAccess().getCollectionTypeIdentifierParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCollectionTypeIdentifier(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnreservedNameAccess().getCollectionTypeIdentifierParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:2679:6: ( rulePrimitiveTypeIdentifier ) |
| { |
| // InternalEssentialOCL.g:2679:6: ( rulePrimitiveTypeIdentifier ) |
| // InternalEssentialOCL.g:2680:1: rulePrimitiveTypeIdentifier |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnreservedNameAccess().getPrimitiveTypeIdentifierParserRuleCall_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePrimitiveTypeIdentifier(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnreservedNameAccess().getPrimitiveTypeIdentifierParserRuleCall_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalEssentialOCL.g:2685:6: ( 'Map' ) |
| { |
| // InternalEssentialOCL.g:2685:6: ( 'Map' ) |
| // InternalEssentialOCL.g:2686:1: 'Map' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnreservedNameAccess().getMapKeyword_3()); |
| } |
| match(input,40,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnreservedNameAccess().getMapKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalEssentialOCL.g:2693:6: ( 'Tuple' ) |
| { |
| // InternalEssentialOCL.g:2693:6: ( 'Tuple' ) |
| // InternalEssentialOCL.g:2694:1: 'Tuple' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEssentialOCLUnreservedNameAccess().getTupleKeyword_4()); |
| } |
| match(input,41,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEssentialOCLUnreservedNameAccess().getTupleKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EssentialOCLUnreservedName__Alternatives" |
| |
| |
| // $ANTLR start "rule__URIFirstPathElementCS__Alternatives" |
| // InternalEssentialOCL.g:2706:1: rule__URIFirstPathElementCS__Alternatives : ( ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) ) | ( ( rule__URIFirstPathElementCS__Group_1__0 ) ) ); |
| public final void rule__URIFirstPathElementCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2710:1: ( ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) ) | ( ( rule__URIFirstPathElementCS__Group_1__0 ) ) ) |
| int alt7=2; |
| int LA7_0 = input.LA(1); |
| |
| if ( ((LA7_0>=RULE_SIMPLE_ID && LA7_0<=RULE_ESCAPED_ID)) ) { |
| alt7=1; |
| } |
| else if ( (LA7_0==RULE_SINGLE_QUOTED_STRING) ) { |
| alt7=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 7, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt7) { |
| case 1 : |
| // InternalEssentialOCL.g:2711:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:2711:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) ) |
| // InternalEssentialOCL.g:2712:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_0()); |
| } |
| // InternalEssentialOCL.g:2713:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) |
| // InternalEssentialOCL.g:2713:2: rule__URIFirstPathElementCS__ReferredElementAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__URIFirstPathElementCS__ReferredElementAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2717:6: ( ( rule__URIFirstPathElementCS__Group_1__0 ) ) |
| { |
| // InternalEssentialOCL.g:2717:6: ( ( rule__URIFirstPathElementCS__Group_1__0 ) ) |
| // InternalEssentialOCL.g:2718:1: ( rule__URIFirstPathElementCS__Group_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIFirstPathElementCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:2719:1: ( rule__URIFirstPathElementCS__Group_1__0 ) |
| // InternalEssentialOCL.g:2719:2: rule__URIFirstPathElementCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__URIFirstPathElementCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIFirstPathElementCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__URIFirstPathElementCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__PrimitiveTypeIdentifier__Alternatives" |
| // InternalEssentialOCL.g:2728:1: rule__PrimitiveTypeIdentifier__Alternatives : ( ( 'Boolean' ) | ( 'Integer' ) | ( 'Real' ) | ( 'String' ) | ( 'UnlimitedNatural' ) | ( 'OclAny' ) | ( 'OclInvalid' ) | ( 'OclVoid' ) ); |
| public final void rule__PrimitiveTypeIdentifier__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2732:1: ( ( 'Boolean' ) | ( 'Integer' ) | ( 'Real' ) | ( 'String' ) | ( 'UnlimitedNatural' ) | ( 'OclAny' ) | ( 'OclInvalid' ) | ( 'OclVoid' ) ) |
| int alt8=8; |
| switch ( input.LA(1) ) { |
| case 42: |
| { |
| alt8=1; |
| } |
| break; |
| case 43: |
| { |
| alt8=2; |
| } |
| break; |
| case 44: |
| { |
| alt8=3; |
| } |
| break; |
| case 45: |
| { |
| alt8=4; |
| } |
| break; |
| case 46: |
| { |
| alt8=5; |
| } |
| break; |
| case 47: |
| { |
| alt8=6; |
| } |
| break; |
| case 48: |
| { |
| alt8=7; |
| } |
| break; |
| case 49: |
| { |
| alt8=8; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 8, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt8) { |
| case 1 : |
| // InternalEssentialOCL.g:2733:1: ( 'Boolean' ) |
| { |
| // InternalEssentialOCL.g:2733:1: ( 'Boolean' ) |
| // InternalEssentialOCL.g:2734:1: 'Boolean' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeIdentifierAccess().getBooleanKeyword_0()); |
| } |
| match(input,42,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeIdentifierAccess().getBooleanKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2741:6: ( 'Integer' ) |
| { |
| // InternalEssentialOCL.g:2741:6: ( 'Integer' ) |
| // InternalEssentialOCL.g:2742:1: 'Integer' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeIdentifierAccess().getIntegerKeyword_1()); |
| } |
| match(input,43,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeIdentifierAccess().getIntegerKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:2749:6: ( 'Real' ) |
| { |
| // InternalEssentialOCL.g:2749:6: ( 'Real' ) |
| // InternalEssentialOCL.g:2750:1: 'Real' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeIdentifierAccess().getRealKeyword_2()); |
| } |
| match(input,44,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeIdentifierAccess().getRealKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalEssentialOCL.g:2757:6: ( 'String' ) |
| { |
| // InternalEssentialOCL.g:2757:6: ( 'String' ) |
| // InternalEssentialOCL.g:2758:1: 'String' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeIdentifierAccess().getStringKeyword_3()); |
| } |
| match(input,45,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeIdentifierAccess().getStringKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalEssentialOCL.g:2765:6: ( 'UnlimitedNatural' ) |
| { |
| // InternalEssentialOCL.g:2765:6: ( 'UnlimitedNatural' ) |
| // InternalEssentialOCL.g:2766:1: 'UnlimitedNatural' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeIdentifierAccess().getUnlimitedNaturalKeyword_4()); |
| } |
| match(input,46,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeIdentifierAccess().getUnlimitedNaturalKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 6 : |
| // InternalEssentialOCL.g:2773:6: ( 'OclAny' ) |
| { |
| // InternalEssentialOCL.g:2773:6: ( 'OclAny' ) |
| // InternalEssentialOCL.g:2774:1: 'OclAny' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclAnyKeyword_5()); |
| } |
| match(input,47,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclAnyKeyword_5()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 7 : |
| // InternalEssentialOCL.g:2781:6: ( 'OclInvalid' ) |
| { |
| // InternalEssentialOCL.g:2781:6: ( 'OclInvalid' ) |
| // InternalEssentialOCL.g:2782:1: 'OclInvalid' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclInvalidKeyword_6()); |
| } |
| match(input,48,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclInvalidKeyword_6()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 8 : |
| // InternalEssentialOCL.g:2789:6: ( 'OclVoid' ) |
| { |
| // InternalEssentialOCL.g:2789:6: ( 'OclVoid' ) |
| // InternalEssentialOCL.g:2790:1: 'OclVoid' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclVoidKeyword_7()); |
| } |
| match(input,49,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclVoidKeyword_7()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimitiveTypeIdentifier__Alternatives" |
| |
| |
| // $ANTLR start "rule__CollectionTypeIdentifier__Alternatives" |
| // InternalEssentialOCL.g:2802:1: rule__CollectionTypeIdentifier__Alternatives : ( ( 'Set' ) | ( 'Bag' ) | ( 'Sequence' ) | ( 'Collection' ) | ( 'OrderedSet' ) ); |
| public final void rule__CollectionTypeIdentifier__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2806:1: ( ( 'Set' ) | ( 'Bag' ) | ( 'Sequence' ) | ( 'Collection' ) | ( 'OrderedSet' ) ) |
| int alt9=5; |
| switch ( input.LA(1) ) { |
| case 50: |
| { |
| alt9=1; |
| } |
| break; |
| case 51: |
| { |
| alt9=2; |
| } |
| break; |
| case 52: |
| { |
| alt9=3; |
| } |
| break; |
| case 53: |
| { |
| alt9=4; |
| } |
| break; |
| case 54: |
| { |
| alt9=5; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 9, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt9) { |
| case 1 : |
| // InternalEssentialOCL.g:2807:1: ( 'Set' ) |
| { |
| // InternalEssentialOCL.g:2807:1: ( 'Set' ) |
| // InternalEssentialOCL.g:2808:1: 'Set' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeIdentifierAccess().getSetKeyword_0()); |
| } |
| match(input,50,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeIdentifierAccess().getSetKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2815:6: ( 'Bag' ) |
| { |
| // InternalEssentialOCL.g:2815:6: ( 'Bag' ) |
| // InternalEssentialOCL.g:2816:1: 'Bag' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeIdentifierAccess().getBagKeyword_1()); |
| } |
| match(input,51,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeIdentifierAccess().getBagKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:2823:6: ( 'Sequence' ) |
| { |
| // InternalEssentialOCL.g:2823:6: ( 'Sequence' ) |
| // InternalEssentialOCL.g:2824:1: 'Sequence' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeIdentifierAccess().getSequenceKeyword_2()); |
| } |
| match(input,52,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeIdentifierAccess().getSequenceKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalEssentialOCL.g:2831:6: ( 'Collection' ) |
| { |
| // InternalEssentialOCL.g:2831:6: ( 'Collection' ) |
| // InternalEssentialOCL.g:2832:1: 'Collection' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeIdentifierAccess().getCollectionKeyword_3()); |
| } |
| match(input,53,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeIdentifierAccess().getCollectionKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalEssentialOCL.g:2839:6: ( 'OrderedSet' ) |
| { |
| // InternalEssentialOCL.g:2839:6: ( 'OrderedSet' ) |
| // InternalEssentialOCL.g:2840:1: 'OrderedSet' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeIdentifierAccess().getOrderedSetKeyword_4()); |
| } |
| match(input,54,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeIdentifierAccess().getOrderedSetKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeIdentifier__Alternatives" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__Alternatives" |
| // InternalEssentialOCL.g:2852:1: rule__CollectionLiteralPartCS__Alternatives : ( ( ( rule__CollectionLiteralPartCS__Group_0__0 ) ) | ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) ) ); |
| public final void rule__CollectionLiteralPartCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2856:1: ( ( ( rule__CollectionLiteralPartCS__Group_0__0 ) ) | ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) ) ) |
| int alt10=2; |
| switch ( input.LA(1) ) { |
| case RULE_INT: |
| case RULE_SINGLE_QUOTED_STRING: |
| case 16: |
| case 17: |
| case 18: |
| case 19: |
| case 40: |
| case 41: |
| case 42: |
| case 43: |
| case 44: |
| case 45: |
| case 46: |
| case 47: |
| case 48: |
| case 49: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 59: |
| case 67: |
| case 68: |
| case 69: |
| case 74: |
| case 79: |
| case 80: |
| case 84: |
| case 85: |
| { |
| alt10=1; |
| } |
| break; |
| case RULE_SIMPLE_ID: |
| { |
| int LA10_2 = input.LA(2); |
| |
| if ( (LA10_2==62) ) { |
| alt10=2; |
| } |
| else if ( (LA10_2==EOF||LA10_2==16||(LA10_2>=19 && LA10_2<=39)||LA10_2==59||LA10_2==61||(LA10_2>=63 && LA10_2<=65)||LA10_2==71||LA10_2==81||LA10_2==86) ) { |
| alt10=1; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 10, 2, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case RULE_ESCAPED_ID: |
| { |
| int LA10_3 = input.LA(2); |
| |
| if ( (LA10_3==EOF||LA10_3==16||(LA10_3>=19 && LA10_3<=39)||LA10_3==59||LA10_3==61||(LA10_3>=63 && LA10_3<=65)||LA10_3==71||LA10_3==81||LA10_3==86) ) { |
| alt10=1; |
| } |
| else if ( (LA10_3==62) ) { |
| alt10=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 10, 3, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 62: |
| { |
| alt10=2; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 10, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt10) { |
| case 1 : |
| // InternalEssentialOCL.g:2857:1: ( ( rule__CollectionLiteralPartCS__Group_0__0 ) ) |
| { |
| // InternalEssentialOCL.g:2857:1: ( ( rule__CollectionLiteralPartCS__Group_0__0 ) ) |
| // InternalEssentialOCL.g:2858:1: ( rule__CollectionLiteralPartCS__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0()); |
| } |
| // InternalEssentialOCL.g:2859:1: ( rule__CollectionLiteralPartCS__Group_0__0 ) |
| // InternalEssentialOCL.g:2859:2: rule__CollectionLiteralPartCS__Group_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralPartCS__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2863:6: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) ) |
| { |
| // InternalEssentialOCL.g:2863:6: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) ) |
| // InternalEssentialOCL.g:2864:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_1()); |
| } |
| // InternalEssentialOCL.g:2865:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) |
| // InternalEssentialOCL.g:2865:2: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralPartCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__ShadowPartCS__Alternatives" |
| // InternalEssentialOCL.g:2874:1: rule__ShadowPartCS__Alternatives : ( ( ( rule__ShadowPartCS__Group_0__0 ) ) | ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) ) ); |
| public final void rule__ShadowPartCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2878:1: ( ( ( rule__ShadowPartCS__Group_0__0 ) ) | ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) ) ) |
| int alt11=2; |
| int LA11_0 = input.LA(1); |
| |
| if ( ((LA11_0>=RULE_SIMPLE_ID && LA11_0<=RULE_ESCAPED_ID)) ) { |
| alt11=1; |
| } |
| else if ( (LA11_0==RULE_SINGLE_QUOTED_STRING) ) { |
| alt11=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 11, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt11) { |
| case 1 : |
| // InternalEssentialOCL.g:2879:1: ( ( rule__ShadowPartCS__Group_0__0 ) ) |
| { |
| // InternalEssentialOCL.g:2879:1: ( ( rule__ShadowPartCS__Group_0__0 ) ) |
| // InternalEssentialOCL.g:2880:1: ( rule__ShadowPartCS__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getGroup_0()); |
| } |
| // InternalEssentialOCL.g:2881:1: ( rule__ShadowPartCS__Group_0__0 ) |
| // InternalEssentialOCL.g:2881:2: rule__ShadowPartCS__Group_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ShadowPartCS__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2885:6: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) ) |
| { |
| // InternalEssentialOCL.g:2885:6: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) ) |
| // InternalEssentialOCL.g:2886:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_1()); |
| } |
| // InternalEssentialOCL.g:2887:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) |
| // InternalEssentialOCL.g:2887:2: rule__ShadowPartCS__OwnedInitExpressionAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ShadowPartCS__OwnedInitExpressionAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ShadowPartCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0" |
| // InternalEssentialOCL.g:2896:1: rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 : ( ( ruleExpCS ) | ( rulePatternExpCS ) ); |
| public final void rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2900:1: ( ( ruleExpCS ) | ( rulePatternExpCS ) ) |
| int alt12=2; |
| switch ( input.LA(1) ) { |
| case RULE_INT: |
| case RULE_SINGLE_QUOTED_STRING: |
| case 16: |
| case 17: |
| case 18: |
| case 19: |
| case 40: |
| case 41: |
| case 42: |
| case 43: |
| case 44: |
| case 45: |
| case 46: |
| case 47: |
| case 48: |
| case 49: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 59: |
| case 67: |
| case 68: |
| case 69: |
| case 74: |
| case 79: |
| case 80: |
| case 84: |
| case 85: |
| { |
| alt12=1; |
| } |
| break; |
| case RULE_SIMPLE_ID: |
| { |
| int LA12_2 = input.LA(2); |
| |
| if ( (LA12_2==62) ) { |
| alt12=2; |
| } |
| else if ( (LA12_2==EOF||LA12_2==16||(LA12_2>=19 && LA12_2<=39)||LA12_2==59||LA12_2==61||(LA12_2>=63 && LA12_2<=64)||LA12_2==71||LA12_2==81||LA12_2==86) ) { |
| alt12=1; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 12, 2, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case RULE_ESCAPED_ID: |
| { |
| int LA12_3 = input.LA(2); |
| |
| if ( (LA12_3==EOF||LA12_3==16||(LA12_3>=19 && LA12_3<=39)||LA12_3==59||LA12_3==61||(LA12_3>=63 && LA12_3<=64)||LA12_3==71||LA12_3==81||LA12_3==86) ) { |
| alt12=1; |
| } |
| else if ( (LA12_3==62) ) { |
| alt12=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 12, 3, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 62: |
| { |
| alt12=2; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 12, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt12) { |
| case 1 : |
| // InternalEssentialOCL.g:2901:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:2901:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:2902:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_2_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2907:6: ( rulePatternExpCS ) |
| { |
| // InternalEssentialOCL.g:2907:6: ( rulePatternExpCS ) |
| // InternalEssentialOCL.g:2908:1: rulePatternExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionPatternExpCSParserRuleCall_0_2_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePatternExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionPatternExpCSParserRuleCall_0_2_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0" |
| |
| |
| // $ANTLR start "rule__MapLiteralPartCS__Alternatives_1" |
| // InternalEssentialOCL.g:2918:1: rule__MapLiteralPartCS__Alternatives_1 : ( ( 'with' ) | ( '<-' ) ); |
| public final void rule__MapLiteralPartCS__Alternatives_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2922:1: ( ( 'with' ) | ( '<-' ) ) |
| int alt13=2; |
| int LA13_0 = input.LA(1); |
| |
| if ( (LA13_0==55) ) { |
| alt13=1; |
| } |
| else if ( (LA13_0==56) ) { |
| alt13=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 13, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt13) { |
| case 1 : |
| // InternalEssentialOCL.g:2923:1: ( 'with' ) |
| { |
| // InternalEssentialOCL.g:2923:1: ( 'with' ) |
| // InternalEssentialOCL.g:2924:1: 'with' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralPartCSAccess().getWithKeyword_1_0()); |
| } |
| match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralPartCSAccess().getWithKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2931:6: ( '<-' ) |
| { |
| // InternalEssentialOCL.g:2931:6: ( '<-' ) |
| // InternalEssentialOCL.g:2932:1: '<-' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralPartCSAccess().getLessThanSignHyphenMinusKeyword_1_1()); |
| } |
| match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralPartCSAccess().getLessThanSignHyphenMinusKeyword_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralPartCS__Alternatives_1" |
| |
| |
| // $ANTLR start "rule__PrimitiveLiteralExpCS__Alternatives" |
| // InternalEssentialOCL.g:2944:1: rule__PrimitiveLiteralExpCS__Alternatives : ( ( ruleNumberLiteralExpCS ) | ( ruleStringLiteralExpCS ) | ( ruleBooleanLiteralExpCS ) | ( ruleUnlimitedNaturalLiteralExpCS ) | ( ruleInvalidLiteralExpCS ) | ( ruleNullLiteralExpCS ) ); |
| public final void rule__PrimitiveLiteralExpCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2948:1: ( ( ruleNumberLiteralExpCS ) | ( ruleStringLiteralExpCS ) | ( ruleBooleanLiteralExpCS ) | ( ruleUnlimitedNaturalLiteralExpCS ) | ( ruleInvalidLiteralExpCS ) | ( ruleNullLiteralExpCS ) ) |
| int alt14=6; |
| switch ( input.LA(1) ) { |
| case RULE_INT: |
| { |
| alt14=1; |
| } |
| break; |
| case RULE_SINGLE_QUOTED_STRING: |
| { |
| alt14=2; |
| } |
| break; |
| case 84: |
| case 85: |
| { |
| alt14=3; |
| } |
| break; |
| case 19: |
| { |
| alt14=4; |
| } |
| break; |
| case 68: |
| { |
| alt14=5; |
| } |
| break; |
| case 69: |
| { |
| alt14=6; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 14, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt14) { |
| case 1 : |
| // InternalEssentialOCL.g:2949:1: ( ruleNumberLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:2949:1: ( ruleNumberLiteralExpCS ) |
| // InternalEssentialOCL.g:2950:1: ruleNumberLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveLiteralExpCSAccess().getNumberLiteralExpCSParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNumberLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveLiteralExpCSAccess().getNumberLiteralExpCSParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:2955:6: ( ruleStringLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:2955:6: ( ruleStringLiteralExpCS ) |
| // InternalEssentialOCL.g:2956:1: ruleStringLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveLiteralExpCSAccess().getStringLiteralExpCSParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleStringLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveLiteralExpCSAccess().getStringLiteralExpCSParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:2961:6: ( ruleBooleanLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:2961:6: ( ruleBooleanLiteralExpCS ) |
| // InternalEssentialOCL.g:2962:1: ruleBooleanLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveLiteralExpCSAccess().getBooleanLiteralExpCSParserRuleCall_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleBooleanLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveLiteralExpCSAccess().getBooleanLiteralExpCSParserRuleCall_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalEssentialOCL.g:2967:6: ( ruleUnlimitedNaturalLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:2967:6: ( ruleUnlimitedNaturalLiteralExpCS ) |
| // InternalEssentialOCL.g:2968:1: ruleUnlimitedNaturalLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSParserRuleCall_3()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnlimitedNaturalLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSParserRuleCall_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalEssentialOCL.g:2973:6: ( ruleInvalidLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:2973:6: ( ruleInvalidLiteralExpCS ) |
| // InternalEssentialOCL.g:2974:1: ruleInvalidLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveLiteralExpCSAccess().getInvalidLiteralExpCSParserRuleCall_4()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleInvalidLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveLiteralExpCSAccess().getInvalidLiteralExpCSParserRuleCall_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 6 : |
| // InternalEssentialOCL.g:2979:6: ( ruleNullLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:2979:6: ( ruleNullLiteralExpCS ) |
| // InternalEssentialOCL.g:2980:1: ruleNullLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveLiteralExpCSAccess().getNullLiteralExpCSParserRuleCall_5()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNullLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveLiteralExpCSAccess().getNullLiteralExpCSParserRuleCall_5()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimitiveLiteralExpCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__BooleanLiteralExpCS__Alternatives" |
| // InternalEssentialOCL.g:2990:1: rule__BooleanLiteralExpCS__Alternatives : ( ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) ) | ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) ) ); |
| public final void rule__BooleanLiteralExpCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:2994:1: ( ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) ) | ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) ) ) |
| int alt15=2; |
| int LA15_0 = input.LA(1); |
| |
| if ( (LA15_0==84) ) { |
| alt15=1; |
| } |
| else if ( (LA15_0==85) ) { |
| alt15=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 15, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt15) { |
| case 1 : |
| // InternalEssentialOCL.g:2995:1: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:2995:1: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) ) |
| // InternalEssentialOCL.g:2996:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_0()); |
| } |
| // InternalEssentialOCL.g:2997:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) |
| // InternalEssentialOCL.g:2997:2: rule__BooleanLiteralExpCS__SymbolAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__BooleanLiteralExpCS__SymbolAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3001:6: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) ) |
| { |
| // InternalEssentialOCL.g:3001:6: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) ) |
| // InternalEssentialOCL.g:3002:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_1()); |
| } |
| // InternalEssentialOCL.g:3003:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) |
| // InternalEssentialOCL.g:3003:2: rule__BooleanLiteralExpCS__SymbolAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__BooleanLiteralExpCS__SymbolAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__BooleanLiteralExpCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__TypeLiteralCS__Alternatives" |
| // InternalEssentialOCL.g:3012:1: rule__TypeLiteralCS__Alternatives : ( ( rulePrimitiveTypeCS ) | ( ruleCollectionTypeCS ) | ( ruleMapTypeCS ) | ( ruleTupleTypeCS ) ); |
| public final void rule__TypeLiteralCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3016:1: ( ( rulePrimitiveTypeCS ) | ( ruleCollectionTypeCS ) | ( ruleMapTypeCS ) | ( ruleTupleTypeCS ) ) |
| int alt16=4; |
| switch ( input.LA(1) ) { |
| case 42: |
| case 43: |
| case 44: |
| case 45: |
| case 46: |
| case 47: |
| case 48: |
| case 49: |
| { |
| alt16=1; |
| } |
| break; |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| { |
| alt16=2; |
| } |
| break; |
| case 40: |
| { |
| alt16=3; |
| } |
| break; |
| case 41: |
| { |
| alt16=4; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 16, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt16) { |
| case 1 : |
| // InternalEssentialOCL.g:3017:1: ( rulePrimitiveTypeCS ) |
| { |
| // InternalEssentialOCL.g:3017:1: ( rulePrimitiveTypeCS ) |
| // InternalEssentialOCL.g:3018:1: rulePrimitiveTypeCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralCSAccess().getPrimitiveTypeCSParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePrimitiveTypeCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralCSAccess().getPrimitiveTypeCSParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3023:6: ( ruleCollectionTypeCS ) |
| { |
| // InternalEssentialOCL.g:3023:6: ( ruleCollectionTypeCS ) |
| // InternalEssentialOCL.g:3024:1: ruleCollectionTypeCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralCSAccess().getCollectionTypeCSParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCollectionTypeCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralCSAccess().getCollectionTypeCSParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:3029:6: ( ruleMapTypeCS ) |
| { |
| // InternalEssentialOCL.g:3029:6: ( ruleMapTypeCS ) |
| // InternalEssentialOCL.g:3030:1: ruleMapTypeCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralCSAccess().getMapTypeCSParserRuleCall_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMapTypeCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralCSAccess().getMapTypeCSParserRuleCall_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalEssentialOCL.g:3035:6: ( ruleTupleTypeCS ) |
| { |
| // InternalEssentialOCL.g:3035:6: ( ruleTupleTypeCS ) |
| // InternalEssentialOCL.g:3036:1: ruleTupleTypeCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralCSAccess().getTupleTypeCSParserRuleCall_3()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTupleTypeCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralCSAccess().getTupleTypeCSParserRuleCall_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeLiteralCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__TypeExpWithoutMultiplicityCS__Alternatives" |
| // InternalEssentialOCL.g:3046:1: rule__TypeExpWithoutMultiplicityCS__Alternatives : ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) ); |
| public final void rule__TypeExpWithoutMultiplicityCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3050:1: ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) ) |
| int alt17=3; |
| alt17 = dfa17.predict(input); |
| switch (alt17) { |
| case 1 : |
| // InternalEssentialOCL.g:3051:1: ( ruleTypeNameExpCS ) |
| { |
| // InternalEssentialOCL.g:3051:1: ( ruleTypeNameExpCS ) |
| // InternalEssentialOCL.g:3052:1: ruleTypeNameExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeNameExpCSParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeNameExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeNameExpCSParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3057:6: ( ruleTypeLiteralCS ) |
| { |
| // InternalEssentialOCL.g:3057:6: ( ruleTypeLiteralCS ) |
| // InternalEssentialOCL.g:3058:1: ruleTypeLiteralCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeLiteralCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:3063:6: ( ruleCollectionPatternCS ) |
| { |
| // InternalEssentialOCL.g:3063:6: ( ruleCollectionPatternCS ) |
| // InternalEssentialOCL.g:3064:1: ruleCollectionPatternCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getCollectionPatternCSParserRuleCall_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCollectionPatternCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getCollectionPatternCSParserRuleCall_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeExpWithoutMultiplicityCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__ExpCS__Alternatives" |
| // InternalEssentialOCL.g:3074:1: rule__ExpCS__Alternatives : ( ( ( rule__ExpCS__Group_0__0 ) ) | ( rulePrefixedLetExpCS ) ); |
| public final void rule__ExpCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3078:1: ( ( ( rule__ExpCS__Group_0__0 ) ) | ( rulePrefixedLetExpCS ) ) |
| int alt18=2; |
| alt18 = dfa18.predict(input); |
| switch (alt18) { |
| case 1 : |
| // InternalEssentialOCL.g:3079:1: ( ( rule__ExpCS__Group_0__0 ) ) |
| { |
| // InternalEssentialOCL.g:3079:1: ( ( rule__ExpCS__Group_0__0 ) ) |
| // InternalEssentialOCL.g:3080:1: ( rule__ExpCS__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSAccess().getGroup_0()); |
| } |
| // InternalEssentialOCL.g:3081:1: ( rule__ExpCS__Group_0__0 ) |
| // InternalEssentialOCL.g:3081:2: rule__ExpCS__Group_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ExpCS__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpCSAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3085:6: ( rulePrefixedLetExpCS ) |
| { |
| // InternalEssentialOCL.g:3085:6: ( rulePrefixedLetExpCS ) |
| // InternalEssentialOCL.g:3086:1: rulePrefixedLetExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSAccess().getPrefixedLetExpCSParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePrefixedLetExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpCSAccess().getPrefixedLetExpCSParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__PrefixedLetExpCS__Alternatives" |
| // InternalEssentialOCL.g:3096:1: rule__PrefixedLetExpCS__Alternatives : ( ( ( rule__PrefixedLetExpCS__Group_0__0 ) ) | ( ruleLetExpCS ) ); |
| public final void rule__PrefixedLetExpCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3100:1: ( ( ( rule__PrefixedLetExpCS__Group_0__0 ) ) | ( ruleLetExpCS ) ) |
| int alt19=2; |
| int LA19_0 = input.LA(1); |
| |
| if ( ((LA19_0>=16 && LA19_0<=18)) ) { |
| alt19=1; |
| } |
| else if ( (LA19_0==79) ) { |
| alt19=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 19, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt19) { |
| case 1 : |
| // InternalEssentialOCL.g:3101:1: ( ( rule__PrefixedLetExpCS__Group_0__0 ) ) |
| { |
| // InternalEssentialOCL.g:3101:1: ( ( rule__PrefixedLetExpCS__Group_0__0 ) ) |
| // InternalEssentialOCL.g:3102:1: ( rule__PrefixedLetExpCS__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedLetExpCSAccess().getGroup_0()); |
| } |
| // InternalEssentialOCL.g:3103:1: ( rule__PrefixedLetExpCS__Group_0__0 ) |
| // InternalEssentialOCL.g:3103:2: rule__PrefixedLetExpCS__Group_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedLetExpCS__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedLetExpCSAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3107:6: ( ruleLetExpCS ) |
| { |
| // InternalEssentialOCL.g:3107:6: ( ruleLetExpCS ) |
| // InternalEssentialOCL.g:3108:1: ruleLetExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedLetExpCSAccess().getLetExpCSParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLetExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedLetExpCSAccess().getLetExpCSParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedLetExpCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__PrefixedPrimaryExpCS__Alternatives" |
| // InternalEssentialOCL.g:3118:1: rule__PrefixedPrimaryExpCS__Alternatives : ( ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) ) | ( rulePrimaryExpCS ) ); |
| public final void rule__PrefixedPrimaryExpCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3122:1: ( ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) ) | ( rulePrimaryExpCS ) ) |
| int alt20=2; |
| int LA20_0 = input.LA(1); |
| |
| if ( ((LA20_0>=16 && LA20_0<=18)) ) { |
| alt20=1; |
| } |
| else if ( ((LA20_0>=RULE_INT && LA20_0<=RULE_ESCAPED_ID)||LA20_0==19||(LA20_0>=40 && LA20_0<=54)||LA20_0==59||(LA20_0>=67 && LA20_0<=69)||LA20_0==74||LA20_0==80||(LA20_0>=84 && LA20_0<=85)) ) { |
| alt20=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 20, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt20) { |
| case 1 : |
| // InternalEssentialOCL.g:3123:1: ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) ) |
| { |
| // InternalEssentialOCL.g:3123:1: ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) ) |
| // InternalEssentialOCL.g:3124:1: ( rule__PrefixedPrimaryExpCS__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedPrimaryExpCSAccess().getGroup_0()); |
| } |
| // InternalEssentialOCL.g:3125:1: ( rule__PrefixedPrimaryExpCS__Group_0__0 ) |
| // InternalEssentialOCL.g:3125:2: rule__PrefixedPrimaryExpCS__Group_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedPrimaryExpCS__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedPrimaryExpCSAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3129:6: ( rulePrimaryExpCS ) |
| { |
| // InternalEssentialOCL.g:3129:6: ( rulePrimaryExpCS ) |
| // InternalEssentialOCL.g:3130:1: rulePrimaryExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrimaryExpCSParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePrimaryExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrimaryExpCSParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedPrimaryExpCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__PrimaryExpCS__Alternatives" |
| // InternalEssentialOCL.g:3140:1: rule__PrimaryExpCS__Alternatives : ( ( ruleNestedExpCS ) | ( ruleIfExpCS ) | ( ruleSelfExpCS ) | ( rulePrimitiveLiteralExpCS ) | ( ruleTupleLiteralExpCS ) | ( ruleMapLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) | ( ruleLambdaLiteralExpCS ) | ( ruleTypeLiteralExpCS ) | ( ruleNameExpCS ) ); |
| public final void rule__PrimaryExpCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3144:1: ( ( ruleNestedExpCS ) | ( ruleIfExpCS ) | ( ruleSelfExpCS ) | ( rulePrimitiveLiteralExpCS ) | ( ruleTupleLiteralExpCS ) | ( ruleMapLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) | ( ruleLambdaLiteralExpCS ) | ( ruleTypeLiteralExpCS ) | ( ruleNameExpCS ) ) |
| int alt21=10; |
| alt21 = dfa21.predict(input); |
| switch (alt21) { |
| case 1 : |
| // InternalEssentialOCL.g:3145:1: ( ruleNestedExpCS ) |
| { |
| // InternalEssentialOCL.g:3145:1: ( ruleNestedExpCS ) |
| // InternalEssentialOCL.g:3146:1: ruleNestedExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getNestedExpCSParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNestedExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSAccess().getNestedExpCSParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3151:6: ( ruleIfExpCS ) |
| { |
| // InternalEssentialOCL.g:3151:6: ( ruleIfExpCS ) |
| // InternalEssentialOCL.g:3152:1: ruleIfExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getIfExpCSParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleIfExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSAccess().getIfExpCSParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:3157:6: ( ruleSelfExpCS ) |
| { |
| // InternalEssentialOCL.g:3157:6: ( ruleSelfExpCS ) |
| // InternalEssentialOCL.g:3158:1: ruleSelfExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getSelfExpCSParserRuleCall_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleSelfExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSAccess().getSelfExpCSParserRuleCall_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalEssentialOCL.g:3163:6: ( rulePrimitiveLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:3163:6: ( rulePrimitiveLiteralExpCS ) |
| // InternalEssentialOCL.g:3164:1: rulePrimitiveLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getPrimitiveLiteralExpCSParserRuleCall_3()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePrimitiveLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSAccess().getPrimitiveLiteralExpCSParserRuleCall_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalEssentialOCL.g:3169:6: ( ruleTupleLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:3169:6: ( ruleTupleLiteralExpCS ) |
| // InternalEssentialOCL.g:3170:1: ruleTupleLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTupleLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 6 : |
| // InternalEssentialOCL.g:3175:6: ( ruleMapLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:3175:6: ( ruleMapLiteralExpCS ) |
| // InternalEssentialOCL.g:3176:1: ruleMapLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMapLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 7 : |
| // InternalEssentialOCL.g:3181:6: ( ruleCollectionLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:3181:6: ( ruleCollectionLiteralExpCS ) |
| // InternalEssentialOCL.g:3182:1: ruleCollectionLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCollectionLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 8 : |
| // InternalEssentialOCL.g:3187:6: ( ruleLambdaLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:3187:6: ( ruleLambdaLiteralExpCS ) |
| // InternalEssentialOCL.g:3188:1: ruleLambdaLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getLambdaLiteralExpCSParserRuleCall_7()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLambdaLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSAccess().getLambdaLiteralExpCSParserRuleCall_7()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 9 : |
| // InternalEssentialOCL.g:3193:6: ( ruleTypeLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:3193:6: ( ruleTypeLiteralExpCS ) |
| // InternalEssentialOCL.g:3194:1: ruleTypeLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 10 : |
| // InternalEssentialOCL.g:3199:6: ( ruleNameExpCS ) |
| { |
| // InternalEssentialOCL.g:3199:6: ( ruleNameExpCS ) |
| // InternalEssentialOCL.g:3200:1: ruleNameExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getNameExpCSParserRuleCall_9()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNameExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimaryExpCSAccess().getNameExpCSParserRuleCall_9()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimaryExpCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0" |
| // InternalEssentialOCL.g:3210:1: rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 : ( ( ruleNavigatingCommaArgCS ) | ( ruleNavigatingSemiArgCS ) | ( ruleNavigatingBarArgCS ) ); |
| public final void rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3214:1: ( ( ruleNavigatingCommaArgCS ) | ( ruleNavigatingSemiArgCS ) | ( ruleNavigatingBarArgCS ) ) |
| int alt22=3; |
| switch ( input.LA(1) ) { |
| case 61: |
| { |
| alt22=1; |
| } |
| break; |
| case 88: |
| { |
| alt22=2; |
| } |
| break; |
| case 87: |
| { |
| alt22=3; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt22) { |
| case 1 : |
| // InternalEssentialOCL.g:3215:1: ( ruleNavigatingCommaArgCS ) |
| { |
| // InternalEssentialOCL.g:3215:1: ( ruleNavigatingCommaArgCS ) |
| // InternalEssentialOCL.g:3216:1: ruleNavigatingCommaArgCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_2_1_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNavigatingCommaArgCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_2_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3221:6: ( ruleNavigatingSemiArgCS ) |
| { |
| // InternalEssentialOCL.g:3221:6: ( ruleNavigatingSemiArgCS ) |
| // InternalEssentialOCL.g:3222:1: ruleNavigatingSemiArgCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingSemiArgCSParserRuleCall_2_1_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNavigatingSemiArgCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingSemiArgCSParserRuleCall_2_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:3227:6: ( ruleNavigatingBarArgCS ) |
| { |
| // InternalEssentialOCL.g:3227:6: ( ruleNavigatingBarArgCS ) |
| // InternalEssentialOCL.g:3228:1: ruleNavigatingBarArgCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingBarArgCSParserRuleCall_2_1_0_2()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNavigatingBarArgCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingBarArgCSParserRuleCall_2_1_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Alternatives" |
| // InternalEssentialOCL.g:3238:1: rule__NavigatingArgCS__Alternatives : ( ( ( rule__NavigatingArgCS__Group_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_1__0 ) ) ); |
| public final void rule__NavigatingArgCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3242:1: ( ( ( rule__NavigatingArgCS__Group_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_1__0 ) ) ) |
| int alt23=2; |
| int LA23_0 = input.LA(1); |
| |
| if ( ((LA23_0>=RULE_INT && LA23_0<=RULE_ESCAPED_ID)||(LA23_0>=16 && LA23_0<=19)||(LA23_0>=40 && LA23_0<=54)||LA23_0==59||(LA23_0>=67 && LA23_0<=69)||LA23_0==74||(LA23_0>=79 && LA23_0<=80)||(LA23_0>=84 && LA23_0<=85)) ) { |
| alt23=1; |
| } |
| else if ( (LA23_0==62) ) { |
| alt23=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 23, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt23) { |
| case 1 : |
| // InternalEssentialOCL.g:3243:1: ( ( rule__NavigatingArgCS__Group_0__0 ) ) |
| { |
| // InternalEssentialOCL.g:3243:1: ( ( rule__NavigatingArgCS__Group_0__0 ) ) |
| // InternalEssentialOCL.g:3244:1: ( rule__NavigatingArgCS__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_0()); |
| } |
| // InternalEssentialOCL.g:3245:1: ( rule__NavigatingArgCS__Group_0__0 ) |
| // InternalEssentialOCL.g:3245:2: rule__NavigatingArgCS__Group_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3249:6: ( ( rule__NavigatingArgCS__Group_1__0 ) ) |
| { |
| // InternalEssentialOCL.g:3249:6: ( ( rule__NavigatingArgCS__Group_1__0 ) ) |
| // InternalEssentialOCL.g:3250:1: ( rule__NavigatingArgCS__Group_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:3251:1: ( rule__NavigatingArgCS__Group_1__0 ) |
| // InternalEssentialOCL.g:3251:2: rule__NavigatingArgCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Alternatives_0_1" |
| // InternalEssentialOCL.g:3260:1: rule__NavigatingArgCS__Alternatives_0_1 : ( ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) ) ); |
| public final void rule__NavigatingArgCS__Alternatives_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3264:1: ( ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) ) ) |
| int alt24=3; |
| switch ( input.LA(1) ) { |
| case 55: |
| { |
| int LA24_1 = input.LA(2); |
| |
| if ( (synpred71_InternalEssentialOCL()) ) { |
| alt24=1; |
| } |
| else if ( (true) ) { |
| alt24=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 24, 1, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 56: |
| { |
| int LA24_2 = input.LA(2); |
| |
| if ( (synpred71_InternalEssentialOCL()) ) { |
| alt24=1; |
| } |
| else if ( (true) ) { |
| alt24=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 24, 2, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 62: |
| { |
| int LA24_3 = input.LA(2); |
| |
| if ( (synpred72_InternalEssentialOCL()) ) { |
| alt24=2; |
| } |
| else if ( (true) ) { |
| alt24=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 24, 3, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 73: |
| { |
| alt24=3; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 24, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt24) { |
| case 1 : |
| // InternalEssentialOCL.g:3265:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) |
| { |
| // InternalEssentialOCL.g:3265:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) |
| // InternalEssentialOCL.g:3266:1: ( rule__NavigatingArgCS__Group_0_1_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0()); |
| } |
| // InternalEssentialOCL.g:3267:1: ( rule__NavigatingArgCS__Group_0_1_0__0 ) |
| // InternalEssentialOCL.g:3267:2: rule__NavigatingArgCS__Group_0_1_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3271:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) |
| { |
| // InternalEssentialOCL.g:3271:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) |
| // InternalEssentialOCL.g:3272:1: ( rule__NavigatingArgCS__Group_0_1_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1()); |
| } |
| // InternalEssentialOCL.g:3273:1: ( rule__NavigatingArgCS__Group_0_1_1__0 ) |
| // InternalEssentialOCL.g:3273:2: rule__NavigatingArgCS__Group_0_1_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:3277:6: ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) ) |
| { |
| // InternalEssentialOCL.g:3277:6: ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) ) |
| // InternalEssentialOCL.g:3278:1: ( rule__NavigatingArgCS__Group_0_1_2__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2()); |
| } |
| // InternalEssentialOCL.g:3279:1: ( rule__NavigatingArgCS__Group_0_1_2__0 ) |
| // InternalEssentialOCL.g:3279:2: rule__NavigatingArgCS__Group_0_1_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Alternatives_0_1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Alternatives_0_1_0_0" |
| // InternalEssentialOCL.g:3288:1: rule__NavigatingArgCS__Alternatives_0_1_0_0 : ( ( 'with' ) | ( '<-' ) ); |
| public final void rule__NavigatingArgCS__Alternatives_0_1_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3292:1: ( ( 'with' ) | ( '<-' ) ) |
| int alt25=2; |
| int LA25_0 = input.LA(1); |
| |
| if ( (LA25_0==55) ) { |
| alt25=1; |
| } |
| else if ( (LA25_0==56) ) { |
| alt25=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 25, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt25) { |
| case 1 : |
| // InternalEssentialOCL.g:3293:1: ( 'with' ) |
| { |
| // InternalEssentialOCL.g:3293:1: ( 'with' ) |
| // InternalEssentialOCL.g:3294:1: 'with' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_0_0_0()); |
| } |
| match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_0_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3301:6: ( '<-' ) |
| { |
| // InternalEssentialOCL.g:3301:6: ( '<-' ) |
| // InternalEssentialOCL.g:3302:1: '<-' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_0_0_1()); |
| } |
| match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_0_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Alternatives_0_1_0_0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Alternatives_0_1_1_2_0" |
| // InternalEssentialOCL.g:3314:1: rule__NavigatingArgCS__Alternatives_0_1_1_2_0 : ( ( 'with' ) | ( '<-' ) ); |
| public final void rule__NavigatingArgCS__Alternatives_0_1_1_2_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3318:1: ( ( 'with' ) | ( '<-' ) ) |
| int alt26=2; |
| int LA26_0 = input.LA(1); |
| |
| if ( (LA26_0==55) ) { |
| alt26=1; |
| } |
| else if ( (LA26_0==56) ) { |
| alt26=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 26, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt26) { |
| case 1 : |
| // InternalEssentialOCL.g:3319:1: ( 'with' ) |
| { |
| // InternalEssentialOCL.g:3319:1: ( 'with' ) |
| // InternalEssentialOCL.g:3320:1: 'with' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_1_2_0_0()); |
| } |
| match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_1_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3327:6: ( '<-' ) |
| { |
| // InternalEssentialOCL.g:3327:6: ( '<-' ) |
| // InternalEssentialOCL.g:3328:1: '<-' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_1_2_0_1()); |
| } |
| match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_1_2_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Alternatives_0_1_1_2_0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Alternatives_0_1_2_1_0" |
| // InternalEssentialOCL.g:3340:1: rule__NavigatingArgCS__Alternatives_0_1_2_1_0 : ( ( 'with' ) | ( '<-' ) ); |
| public final void rule__NavigatingArgCS__Alternatives_0_1_2_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3344:1: ( ( 'with' ) | ( '<-' ) ) |
| int alt27=2; |
| int LA27_0 = input.LA(1); |
| |
| if ( (LA27_0==55) ) { |
| alt27=1; |
| } |
| else if ( (LA27_0==56) ) { |
| alt27=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 27, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt27) { |
| case 1 : |
| // InternalEssentialOCL.g:3345:1: ( 'with' ) |
| { |
| // InternalEssentialOCL.g:3345:1: ( 'with' ) |
| // InternalEssentialOCL.g:3346:1: 'with' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_2_1_0_0()); |
| } |
| match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_2_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3353:6: ( '<-' ) |
| { |
| // InternalEssentialOCL.g:3353:6: ( '<-' ) |
| // InternalEssentialOCL.g:3354:1: '<-' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_2_1_0_1()); |
| } |
| match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_2_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Alternatives_0_1_2_1_0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Alternatives_2" |
| // InternalEssentialOCL.g:3366:1: rule__NavigatingCommaArgCS__Alternatives_2 : ( ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) ) ); |
| public final void rule__NavigatingCommaArgCS__Alternatives_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3370:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) ) ) |
| int alt28=3; |
| switch ( input.LA(1) ) { |
| case 55: |
| { |
| int LA28_1 = input.LA(2); |
| |
| if ( (synpred76_InternalEssentialOCL()) ) { |
| alt28=1; |
| } |
| else if ( (true) ) { |
| alt28=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 28, 1, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 56: |
| { |
| int LA28_2 = input.LA(2); |
| |
| if ( (synpred76_InternalEssentialOCL()) ) { |
| alt28=1; |
| } |
| else if ( (true) ) { |
| alt28=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 28, 2, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 62: |
| { |
| int LA28_3 = input.LA(2); |
| |
| if ( (synpred77_InternalEssentialOCL()) ) { |
| alt28=2; |
| } |
| else if ( (true) ) { |
| alt28=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 28, 3, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 73: |
| { |
| alt28=3; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 28, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt28) { |
| case 1 : |
| // InternalEssentialOCL.g:3371:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) |
| { |
| // InternalEssentialOCL.g:3371:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) |
| // InternalEssentialOCL.g:3372:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0()); |
| } |
| // InternalEssentialOCL.g:3373:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 ) |
| // InternalEssentialOCL.g:3373:2: rule__NavigatingCommaArgCS__Group_2_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3377:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) |
| { |
| // InternalEssentialOCL.g:3377:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) |
| // InternalEssentialOCL.g:3378:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1()); |
| } |
| // InternalEssentialOCL.g:3379:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 ) |
| // InternalEssentialOCL.g:3379:2: rule__NavigatingCommaArgCS__Group_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:3383:6: ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) ) |
| { |
| // InternalEssentialOCL.g:3383:6: ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) ) |
| // InternalEssentialOCL.g:3384:1: ( rule__NavigatingCommaArgCS__Group_2_2__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2()); |
| } |
| // InternalEssentialOCL.g:3385:1: ( rule__NavigatingCommaArgCS__Group_2_2__0 ) |
| // InternalEssentialOCL.g:3385:2: rule__NavigatingCommaArgCS__Group_2_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Alternatives_2" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Alternatives_2_0_0" |
| // InternalEssentialOCL.g:3394:1: rule__NavigatingCommaArgCS__Alternatives_2_0_0 : ( ( 'with' ) | ( '<-' ) ); |
| public final void rule__NavigatingCommaArgCS__Alternatives_2_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3398:1: ( ( 'with' ) | ( '<-' ) ) |
| int alt29=2; |
| int LA29_0 = input.LA(1); |
| |
| if ( (LA29_0==55) ) { |
| alt29=1; |
| } |
| else if ( (LA29_0==56) ) { |
| alt29=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 29, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt29) { |
| case 1 : |
| // InternalEssentialOCL.g:3399:1: ( 'with' ) |
| { |
| // InternalEssentialOCL.g:3399:1: ( 'with' ) |
| // InternalEssentialOCL.g:3400:1: 'with' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_0_0_0()); |
| } |
| match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_0_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3407:6: ( '<-' ) |
| { |
| // InternalEssentialOCL.g:3407:6: ( '<-' ) |
| // InternalEssentialOCL.g:3408:1: '<-' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_0_0_1()); |
| } |
| match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_0_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Alternatives_2_0_0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Alternatives_2_1_2_0" |
| // InternalEssentialOCL.g:3420:1: rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 : ( ( 'with' ) | ( '<-' ) ); |
| public final void rule__NavigatingCommaArgCS__Alternatives_2_1_2_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3424:1: ( ( 'with' ) | ( '<-' ) ) |
| int alt30=2; |
| int LA30_0 = input.LA(1); |
| |
| if ( (LA30_0==55) ) { |
| alt30=1; |
| } |
| else if ( (LA30_0==56) ) { |
| alt30=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 30, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt30) { |
| case 1 : |
| // InternalEssentialOCL.g:3425:1: ( 'with' ) |
| { |
| // InternalEssentialOCL.g:3425:1: ( 'with' ) |
| // InternalEssentialOCL.g:3426:1: 'with' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_1_2_0_0()); |
| } |
| match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_1_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3433:6: ( '<-' ) |
| { |
| // InternalEssentialOCL.g:3433:6: ( '<-' ) |
| // InternalEssentialOCL.g:3434:1: '<-' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_1_2_0_1()); |
| } |
| match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_1_2_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Alternatives_2_1_2_0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Alternatives_2_2_1_0" |
| // InternalEssentialOCL.g:3446:1: rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 : ( ( 'with' ) | ( '<-' ) ); |
| public final void rule__NavigatingCommaArgCS__Alternatives_2_2_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3450:1: ( ( 'with' ) | ( '<-' ) ) |
| int alt31=2; |
| int LA31_0 = input.LA(1); |
| |
| if ( (LA31_0==55) ) { |
| alt31=1; |
| } |
| else if ( (LA31_0==56) ) { |
| alt31=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 31, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt31) { |
| case 1 : |
| // InternalEssentialOCL.g:3451:1: ( 'with' ) |
| { |
| // InternalEssentialOCL.g:3451:1: ( 'with' ) |
| // InternalEssentialOCL.g:3452:1: 'with' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_2_1_0_0()); |
| } |
| match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_2_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3459:6: ( '<-' ) |
| { |
| // InternalEssentialOCL.g:3459:6: ( '<-' ) |
| // InternalEssentialOCL.g:3460:1: '<-' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_2_1_0_1()); |
| } |
| match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_2_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Alternatives_2_2_1_0" |
| |
| |
| // $ANTLR start "rule__IfExpCS__OwnedConditionAlternatives_1_0" |
| // InternalEssentialOCL.g:3472:1: rule__IfExpCS__OwnedConditionAlternatives_1_0 : ( ( ruleExpCS ) | ( rulePatternExpCS ) ); |
| public final void rule__IfExpCS__OwnedConditionAlternatives_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3476:1: ( ( ruleExpCS ) | ( rulePatternExpCS ) ) |
| int alt32=2; |
| switch ( input.LA(1) ) { |
| case RULE_INT: |
| case RULE_SINGLE_QUOTED_STRING: |
| case 16: |
| case 17: |
| case 18: |
| case 19: |
| case 40: |
| case 41: |
| case 42: |
| case 43: |
| case 44: |
| case 45: |
| case 46: |
| case 47: |
| case 48: |
| case 49: |
| case 50: |
| case 51: |
| case 52: |
| case 53: |
| case 54: |
| case 59: |
| case 67: |
| case 68: |
| case 69: |
| case 74: |
| case 79: |
| case 80: |
| case 84: |
| case 85: |
| { |
| alt32=1; |
| } |
| break; |
| case RULE_SIMPLE_ID: |
| { |
| int LA32_2 = input.LA(2); |
| |
| if ( (LA32_2==16||(LA32_2>=19 && LA32_2<=39)||LA32_2==59||LA32_2==63||LA32_2==71||LA32_2==75||LA32_2==81||LA32_2==86) ) { |
| alt32=1; |
| } |
| else if ( (LA32_2==62) ) { |
| alt32=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 32, 2, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case RULE_ESCAPED_ID: |
| { |
| int LA32_3 = input.LA(2); |
| |
| if ( (LA32_3==62) ) { |
| alt32=2; |
| } |
| else if ( (LA32_3==16||(LA32_3>=19 && LA32_3<=39)||LA32_3==59||LA32_3==63||LA32_3==71||LA32_3==75||LA32_3==81||LA32_3==86) ) { |
| alt32=1; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 32, 3, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 62: |
| { |
| alt32=2; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 32, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt32) { |
| case 1 : |
| // InternalEssentialOCL.g:3477:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:3477:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:3478:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3483:6: ( rulePatternExpCS ) |
| { |
| // InternalEssentialOCL.g:3483:6: ( rulePatternExpCS ) |
| // InternalEssentialOCL.g:3484:1: rulePatternExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getOwnedConditionPatternExpCSParserRuleCall_1_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePatternExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getOwnedConditionPatternExpCSParserRuleCall_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__OwnedConditionAlternatives_1_0" |
| |
| |
| // $ANTLR start "rule__MultiplicityCS__Alternatives_1" |
| // InternalEssentialOCL.g:3494:1: rule__MultiplicityCS__Alternatives_1 : ( ( ruleMultiplicityBoundsCS ) | ( ruleMultiplicityStringCS ) ); |
| public final void rule__MultiplicityCS__Alternatives_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3498:1: ( ( ruleMultiplicityBoundsCS ) | ( ruleMultiplicityStringCS ) ) |
| int alt33=2; |
| int LA33_0 = input.LA(1); |
| |
| if ( (LA33_0==RULE_INT) ) { |
| alt33=1; |
| } |
| else if ( (LA33_0==19||LA33_0==21||LA33_0==58) ) { |
| alt33=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 33, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt33) { |
| case 1 : |
| // InternalEssentialOCL.g:3499:1: ( ruleMultiplicityBoundsCS ) |
| { |
| // InternalEssentialOCL.g:3499:1: ( ruleMultiplicityBoundsCS ) |
| // InternalEssentialOCL.g:3500:1: ruleMultiplicityBoundsCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSAccess().getMultiplicityBoundsCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMultiplicityBoundsCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSAccess().getMultiplicityBoundsCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3505:6: ( ruleMultiplicityStringCS ) |
| { |
| // InternalEssentialOCL.g:3505:6: ( ruleMultiplicityStringCS ) |
| // InternalEssentialOCL.g:3506:1: ruleMultiplicityStringCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSAccess().getMultiplicityStringCSParserRuleCall_1_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMultiplicityStringCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSAccess().getMultiplicityStringCSParserRuleCall_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityCS__Alternatives_1" |
| |
| |
| // $ANTLR start "rule__MultiplicityCS__Alternatives_2" |
| // InternalEssentialOCL.g:3516:1: rule__MultiplicityCS__Alternatives_2 : ( ( '|?' ) | ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) ) ); |
| public final void rule__MultiplicityCS__Alternatives_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3520:1: ( ( '|?' ) | ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) ) ) |
| int alt34=2; |
| int LA34_0 = input.LA(1); |
| |
| if ( (LA34_0==57) ) { |
| alt34=1; |
| } |
| else if ( (LA34_0==89) ) { |
| alt34=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 34, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt34) { |
| case 1 : |
| // InternalEssentialOCL.g:3521:1: ( '|?' ) |
| { |
| // InternalEssentialOCL.g:3521:1: ( '|?' ) |
| // InternalEssentialOCL.g:3522:1: '|?' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSAccess().getVerticalLineQuestionMarkKeyword_2_0()); |
| } |
| match(input,57,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSAccess().getVerticalLineQuestionMarkKeyword_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3529:6: ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:3529:6: ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) ) |
| // InternalEssentialOCL.g:3530:1: ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSAccess().getIsNullFreeAssignment_2_1()); |
| } |
| // InternalEssentialOCL.g:3531:1: ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) |
| // InternalEssentialOCL.g:3531:2: rule__MultiplicityCS__IsNullFreeAssignment_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityCS__IsNullFreeAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSAccess().getIsNullFreeAssignment_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityCS__Alternatives_2" |
| |
| |
| // $ANTLR start "rule__MultiplicityStringCS__StringBoundsAlternatives_0" |
| // InternalEssentialOCL.g:3540:1: rule__MultiplicityStringCS__StringBoundsAlternatives_0 : ( ( '*' ) | ( '+' ) | ( '?' ) ); |
| public final void rule__MultiplicityStringCS__StringBoundsAlternatives_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3544:1: ( ( '*' ) | ( '+' ) | ( '?' ) ) |
| int alt35=3; |
| switch ( input.LA(1) ) { |
| case 19: |
| { |
| alt35=1; |
| } |
| break; |
| case 21: |
| { |
| alt35=2; |
| } |
| break; |
| case 58: |
| { |
| alt35=3; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 35, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt35) { |
| case 1 : |
| // InternalEssentialOCL.g:3545:1: ( '*' ) |
| { |
| // InternalEssentialOCL.g:3545:1: ( '*' ) |
| // InternalEssentialOCL.g:3546:1: '*' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAsteriskKeyword_0_0()); |
| } |
| match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAsteriskKeyword_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3553:6: ( '+' ) |
| { |
| // InternalEssentialOCL.g:3553:6: ( '+' ) |
| // InternalEssentialOCL.g:3554:1: '+' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsPlusSignKeyword_0_1()); |
| } |
| match(input,21,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsPlusSignKeyword_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalEssentialOCL.g:3561:6: ( '?' ) |
| { |
| // InternalEssentialOCL.g:3561:6: ( '?' ) |
| // InternalEssentialOCL.g:3562:1: '?' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsQuestionMarkKeyword_0_2()); |
| } |
| match(input,58,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsQuestionMarkKeyword_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityStringCS__StringBoundsAlternatives_0" |
| |
| |
| // $ANTLR start "rule__TypeRefCS__Alternatives" |
| // InternalEssentialOCL.g:3574:1: rule__TypeRefCS__Alternatives : ( ( ruleTypedRefCS ) | ( ruleWildcardTypeRefCS ) ); |
| public final void rule__TypeRefCS__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3578:1: ( ( ruleTypedRefCS ) | ( ruleWildcardTypeRefCS ) ) |
| int alt36=2; |
| int LA36_0 = input.LA(1); |
| |
| if ( ((LA36_0>=RULE_SIMPLE_ID && LA36_0<=RULE_ESCAPED_ID)) ) { |
| alt36=1; |
| } |
| else if ( (LA36_0==58) ) { |
| alt36=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 36, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt36) { |
| case 1 : |
| // InternalEssentialOCL.g:3579:1: ( ruleTypedRefCS ) |
| { |
| // InternalEssentialOCL.g:3579:1: ( ruleTypedRefCS ) |
| // InternalEssentialOCL.g:3580:1: ruleTypedRefCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeRefCSAccess().getTypedRefCSParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypedRefCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeRefCSAccess().getTypedRefCSParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3585:6: ( ruleWildcardTypeRefCS ) |
| { |
| // InternalEssentialOCL.g:3585:6: ( ruleWildcardTypeRefCS ) |
| // InternalEssentialOCL.g:3586:1: ruleWildcardTypeRefCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeRefCSAccess().getWildcardTypeRefCSParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleWildcardTypeRefCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeRefCSAccess().getWildcardTypeRefCSParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeRefCS__Alternatives" |
| |
| |
| // $ANTLR start "rule__ID__Alternatives" |
| // InternalEssentialOCL.g:3596:1: rule__ID__Alternatives : ( ( RULE_SIMPLE_ID ) | ( RULE_ESCAPED_ID ) ); |
| public final void rule__ID__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3600:1: ( ( RULE_SIMPLE_ID ) | ( RULE_ESCAPED_ID ) ) |
| int alt37=2; |
| int LA37_0 = input.LA(1); |
| |
| if ( (LA37_0==RULE_SIMPLE_ID) ) { |
| alt37=1; |
| } |
| else if ( (LA37_0==RULE_ESCAPED_ID) ) { |
| alt37=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 37, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt37) { |
| case 1 : |
| // InternalEssentialOCL.g:3601:1: ( RULE_SIMPLE_ID ) |
| { |
| // InternalEssentialOCL.g:3601:1: ( RULE_SIMPLE_ID ) |
| // InternalEssentialOCL.g:3602:1: RULE_SIMPLE_ID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIDAccess().getSIMPLE_IDTerminalRuleCall_0()); |
| } |
| match(input,RULE_SIMPLE_ID,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIDAccess().getSIMPLE_IDTerminalRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3607:6: ( RULE_ESCAPED_ID ) |
| { |
| // InternalEssentialOCL.g:3607:6: ( RULE_ESCAPED_ID ) |
| // InternalEssentialOCL.g:3608:1: RULE_ESCAPED_ID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIDAccess().getESCAPED_IDTerminalRuleCall_1()); |
| } |
| match(input,RULE_ESCAPED_ID,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIDAccess().getESCAPED_IDTerminalRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ID__Alternatives" |
| |
| |
| // $ANTLR start "rule__UPPER__Alternatives" |
| // InternalEssentialOCL.g:3618:1: rule__UPPER__Alternatives : ( ( RULE_INT ) | ( '*' ) ); |
| public final void rule__UPPER__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3622:1: ( ( RULE_INT ) | ( '*' ) ) |
| int alt38=2; |
| int LA38_0 = input.LA(1); |
| |
| if ( (LA38_0==RULE_INT) ) { |
| alt38=1; |
| } |
| else if ( (LA38_0==19) ) { |
| alt38=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 38, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt38) { |
| case 1 : |
| // InternalEssentialOCL.g:3623:1: ( RULE_INT ) |
| { |
| // InternalEssentialOCL.g:3623:1: ( RULE_INT ) |
| // InternalEssentialOCL.g:3624:1: RULE_INT |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUPPERAccess().getINTTerminalRuleCall_0()); |
| } |
| match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUPPERAccess().getINTTerminalRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalEssentialOCL.g:3629:6: ( '*' ) |
| { |
| // InternalEssentialOCL.g:3629:6: ( '*' ) |
| // InternalEssentialOCL.g:3630:1: '*' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUPPERAccess().getAsteriskKeyword_1()); |
| } |
| match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUPPERAccess().getAsteriskKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UPPER__Alternatives" |
| |
| |
| // $ANTLR start "rule__URIFirstPathElementCS__Group_1__0" |
| // InternalEssentialOCL.g:3646:1: rule__URIFirstPathElementCS__Group_1__0 : rule__URIFirstPathElementCS__Group_1__0__Impl rule__URIFirstPathElementCS__Group_1__1 ; |
| public final void rule__URIFirstPathElementCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3650:1: ( rule__URIFirstPathElementCS__Group_1__0__Impl rule__URIFirstPathElementCS__Group_1__1 ) |
| // InternalEssentialOCL.g:3651:2: rule__URIFirstPathElementCS__Group_1__0__Impl rule__URIFirstPathElementCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_4); |
| rule__URIFirstPathElementCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__URIFirstPathElementCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__URIFirstPathElementCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__URIFirstPathElementCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:3658:1: rule__URIFirstPathElementCS__Group_1__0__Impl : ( () ) ; |
| public final void rule__URIFirstPathElementCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3662:1: ( ( () ) ) |
| // InternalEssentialOCL.g:3663:1: ( () ) |
| { |
| // InternalEssentialOCL.g:3663:1: ( () ) |
| // InternalEssentialOCL.g:3664:1: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIFirstPathElementCSAccess().getPathElementWithURICSAction_1_0()); |
| } |
| // InternalEssentialOCL.g:3665:1: () |
| // InternalEssentialOCL.g:3667:1: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIFirstPathElementCSAccess().getPathElementWithURICSAction_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__URIFirstPathElementCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__URIFirstPathElementCS__Group_1__1" |
| // InternalEssentialOCL.g:3677:1: rule__URIFirstPathElementCS__Group_1__1 : rule__URIFirstPathElementCS__Group_1__1__Impl ; |
| public final void rule__URIFirstPathElementCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3681:1: ( rule__URIFirstPathElementCS__Group_1__1__Impl ) |
| // InternalEssentialOCL.g:3682:2: rule__URIFirstPathElementCS__Group_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__URIFirstPathElementCS__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__URIFirstPathElementCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__URIFirstPathElementCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:3688:1: rule__URIFirstPathElementCS__Group_1__1__Impl : ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) ) ; |
| public final void rule__URIFirstPathElementCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3692:1: ( ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) ) ) |
| // InternalEssentialOCL.g:3693:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:3693:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) ) |
| // InternalEssentialOCL.g:3694:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_1_1()); |
| } |
| // InternalEssentialOCL.g:3695:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) |
| // InternalEssentialOCL.g:3695:2: rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__URIFirstPathElementCS__ReferredElementAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__URIFirstPathElementCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group__0" |
| // InternalEssentialOCL.g:3709:1: rule__CollectionTypeCS__Group__0 : rule__CollectionTypeCS__Group__0__Impl rule__CollectionTypeCS__Group__1 ; |
| public final void rule__CollectionTypeCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3713:1: ( rule__CollectionTypeCS__Group__0__Impl rule__CollectionTypeCS__Group__1 ) |
| // InternalEssentialOCL.g:3714:2: rule__CollectionTypeCS__Group__0__Impl rule__CollectionTypeCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_5); |
| rule__CollectionTypeCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__Group__0" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group__0__Impl" |
| // InternalEssentialOCL.g:3721:1: rule__CollectionTypeCS__Group__0__Impl : ( ( rule__CollectionTypeCS__NameAssignment_0 ) ) ; |
| public final void rule__CollectionTypeCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3725:1: ( ( ( rule__CollectionTypeCS__NameAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:3726:1: ( ( rule__CollectionTypeCS__NameAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:3726:1: ( ( rule__CollectionTypeCS__NameAssignment_0 ) ) |
| // InternalEssentialOCL.g:3727:1: ( rule__CollectionTypeCS__NameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeCSAccess().getNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:3728:1: ( rule__CollectionTypeCS__NameAssignment_0 ) |
| // InternalEssentialOCL.g:3728:2: rule__CollectionTypeCS__NameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeCS__NameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeCSAccess().getNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group__1" |
| // InternalEssentialOCL.g:3738:1: rule__CollectionTypeCS__Group__1 : rule__CollectionTypeCS__Group__1__Impl ; |
| public final void rule__CollectionTypeCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3742:1: ( rule__CollectionTypeCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:3743:2: rule__CollectionTypeCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__Group__1" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group__1__Impl" |
| // InternalEssentialOCL.g:3749:1: rule__CollectionTypeCS__Group__1__Impl : ( ( rule__CollectionTypeCS__Group_1__0 )? ) ; |
| public final void rule__CollectionTypeCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3753:1: ( ( ( rule__CollectionTypeCS__Group_1__0 )? ) ) |
| // InternalEssentialOCL.g:3754:1: ( ( rule__CollectionTypeCS__Group_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:3754:1: ( ( rule__CollectionTypeCS__Group_1__0 )? ) |
| // InternalEssentialOCL.g:3755:1: ( rule__CollectionTypeCS__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:3756:1: ( rule__CollectionTypeCS__Group_1__0 )? |
| int alt39=2; |
| int LA39_0 = input.LA(1); |
| |
| if ( (LA39_0==59) ) { |
| alt39=1; |
| } |
| switch (alt39) { |
| case 1 : |
| // InternalEssentialOCL.g:3756:2: rule__CollectionTypeCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group_1__0" |
| // InternalEssentialOCL.g:3770:1: rule__CollectionTypeCS__Group_1__0 : rule__CollectionTypeCS__Group_1__0__Impl rule__CollectionTypeCS__Group_1__1 ; |
| public final void rule__CollectionTypeCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3774:1: ( rule__CollectionTypeCS__Group_1__0__Impl rule__CollectionTypeCS__Group_1__1 ) |
| // InternalEssentialOCL.g:3775:2: rule__CollectionTypeCS__Group_1__0__Impl rule__CollectionTypeCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__CollectionTypeCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:3782:1: rule__CollectionTypeCS__Group_1__0__Impl : ( '(' ) ; |
| public final void rule__CollectionTypeCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3786:1: ( ( '(' ) ) |
| // InternalEssentialOCL.g:3787:1: ( '(' ) |
| { |
| // InternalEssentialOCL.g:3787:1: ( '(' ) |
| // InternalEssentialOCL.g:3788:1: '(' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeCSAccess().getLeftParenthesisKeyword_1_0()); |
| } |
| match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeCSAccess().getLeftParenthesisKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group_1__1" |
| // InternalEssentialOCL.g:3801:1: rule__CollectionTypeCS__Group_1__1 : rule__CollectionTypeCS__Group_1__1__Impl rule__CollectionTypeCS__Group_1__2 ; |
| public final void rule__CollectionTypeCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3805:1: ( rule__CollectionTypeCS__Group_1__1__Impl rule__CollectionTypeCS__Group_1__2 ) |
| // InternalEssentialOCL.g:3806:2: rule__CollectionTypeCS__Group_1__1__Impl rule__CollectionTypeCS__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_7); |
| rule__CollectionTypeCS__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeCS__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:3813:1: rule__CollectionTypeCS__Group_1__1__Impl : ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) ) ; |
| public final void rule__CollectionTypeCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3817:1: ( ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) ) ) |
| // InternalEssentialOCL.g:3818:1: ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:3818:1: ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) ) |
| // InternalEssentialOCL.g:3819:1: ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeAssignment_1_1()); |
| } |
| // InternalEssentialOCL.g:3820:1: ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) |
| // InternalEssentialOCL.g:3820:2: rule__CollectionTypeCS__OwnedTypeAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeCS__OwnedTypeAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group_1__2" |
| // InternalEssentialOCL.g:3830:1: rule__CollectionTypeCS__Group_1__2 : rule__CollectionTypeCS__Group_1__2__Impl rule__CollectionTypeCS__Group_1__3 ; |
| public final void rule__CollectionTypeCS__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3834:1: ( rule__CollectionTypeCS__Group_1__2__Impl rule__CollectionTypeCS__Group_1__3 ) |
| // InternalEssentialOCL.g:3835:2: rule__CollectionTypeCS__Group_1__2__Impl rule__CollectionTypeCS__Group_1__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_7); |
| rule__CollectionTypeCS__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeCS__Group_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__Group_1__2" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group_1__2__Impl" |
| // InternalEssentialOCL.g:3842:1: rule__CollectionTypeCS__Group_1__2__Impl : ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? ) ; |
| public final void rule__CollectionTypeCS__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3846:1: ( ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? ) ) |
| // InternalEssentialOCL.g:3847:1: ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? ) |
| { |
| // InternalEssentialOCL.g:3847:1: ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? ) |
| // InternalEssentialOCL.g:3848:1: ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityAssignment_1_2()); |
| } |
| // InternalEssentialOCL.g:3849:1: ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? |
| int alt40=2; |
| int LA40_0 = input.LA(1); |
| |
| if ( (LA40_0==71) ) { |
| alt40=1; |
| } |
| switch (alt40) { |
| case 1 : |
| // InternalEssentialOCL.g:3849:2: rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityAssignment_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group_1__3" |
| // InternalEssentialOCL.g:3859:1: rule__CollectionTypeCS__Group_1__3 : rule__CollectionTypeCS__Group_1__3__Impl ; |
| public final void rule__CollectionTypeCS__Group_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3863:1: ( rule__CollectionTypeCS__Group_1__3__Impl ) |
| // InternalEssentialOCL.g:3864:2: rule__CollectionTypeCS__Group_1__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionTypeCS__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__CollectionTypeCS__Group_1__3" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__Group_1__3__Impl" |
| // InternalEssentialOCL.g:3870:1: rule__CollectionTypeCS__Group_1__3__Impl : ( ')' ) ; |
| public final void rule__CollectionTypeCS__Group_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3874:1: ( ( ')' ) ) |
| // InternalEssentialOCL.g:3875:1: ( ')' ) |
| { |
| // InternalEssentialOCL.g:3875:1: ( ')' ) |
| // InternalEssentialOCL.g:3876:1: ')' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeCSAccess().getRightParenthesisKeyword_1_3()); |
| } |
| match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeCSAccess().getRightParenthesisKeyword_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__Group_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group__0" |
| // InternalEssentialOCL.g:3897:1: rule__MapTypeCS__Group__0 : rule__MapTypeCS__Group__0__Impl rule__MapTypeCS__Group__1 ; |
| public final void rule__MapTypeCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3901:1: ( rule__MapTypeCS__Group__0__Impl rule__MapTypeCS__Group__1 ) |
| // InternalEssentialOCL.g:3902:2: rule__MapTypeCS__Group__0__Impl rule__MapTypeCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_5); |
| rule__MapTypeCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group__0" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group__0__Impl" |
| // InternalEssentialOCL.g:3909:1: rule__MapTypeCS__Group__0__Impl : ( ( rule__MapTypeCS__NameAssignment_0 ) ) ; |
| public final void rule__MapTypeCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3913:1: ( ( ( rule__MapTypeCS__NameAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:3914:1: ( ( rule__MapTypeCS__NameAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:3914:1: ( ( rule__MapTypeCS__NameAssignment_0 ) ) |
| // InternalEssentialOCL.g:3915:1: ( rule__MapTypeCS__NameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:3916:1: ( rule__MapTypeCS__NameAssignment_0 ) |
| // InternalEssentialOCL.g:3916:2: rule__MapTypeCS__NameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__NameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group__1" |
| // InternalEssentialOCL.g:3926:1: rule__MapTypeCS__Group__1 : rule__MapTypeCS__Group__1__Impl ; |
| public final void rule__MapTypeCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3930:1: ( rule__MapTypeCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:3931:2: rule__MapTypeCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group__1" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group__1__Impl" |
| // InternalEssentialOCL.g:3937:1: rule__MapTypeCS__Group__1__Impl : ( ( rule__MapTypeCS__Group_1__0 )? ) ; |
| public final void rule__MapTypeCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3941:1: ( ( ( rule__MapTypeCS__Group_1__0 )? ) ) |
| // InternalEssentialOCL.g:3942:1: ( ( rule__MapTypeCS__Group_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:3942:1: ( ( rule__MapTypeCS__Group_1__0 )? ) |
| // InternalEssentialOCL.g:3943:1: ( rule__MapTypeCS__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:3944:1: ( rule__MapTypeCS__Group_1__0 )? |
| int alt41=2; |
| int LA41_0 = input.LA(1); |
| |
| if ( (LA41_0==59) ) { |
| alt41=1; |
| } |
| switch (alt41) { |
| case 1 : |
| // InternalEssentialOCL.g:3944:2: rule__MapTypeCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group_1__0" |
| // InternalEssentialOCL.g:3958:1: rule__MapTypeCS__Group_1__0 : rule__MapTypeCS__Group_1__0__Impl rule__MapTypeCS__Group_1__1 ; |
| public final void rule__MapTypeCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3962:1: ( rule__MapTypeCS__Group_1__0__Impl rule__MapTypeCS__Group_1__1 ) |
| // InternalEssentialOCL.g:3963:2: rule__MapTypeCS__Group_1__0__Impl rule__MapTypeCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__MapTypeCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:3970:1: rule__MapTypeCS__Group_1__0__Impl : ( '(' ) ; |
| public final void rule__MapTypeCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3974:1: ( ( '(' ) ) |
| // InternalEssentialOCL.g:3975:1: ( '(' ) |
| { |
| // InternalEssentialOCL.g:3975:1: ( '(' ) |
| // InternalEssentialOCL.g:3976:1: '(' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getLeftParenthesisKeyword_1_0()); |
| } |
| match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getLeftParenthesisKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group_1__1" |
| // InternalEssentialOCL.g:3989:1: rule__MapTypeCS__Group_1__1 : rule__MapTypeCS__Group_1__1__Impl rule__MapTypeCS__Group_1__2 ; |
| public final void rule__MapTypeCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:3993:1: ( rule__MapTypeCS__Group_1__1__Impl rule__MapTypeCS__Group_1__2 ) |
| // InternalEssentialOCL.g:3994:2: rule__MapTypeCS__Group_1__1__Impl rule__MapTypeCS__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_8); |
| rule__MapTypeCS__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:4001:1: rule__MapTypeCS__Group_1__1__Impl : ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) ) ; |
| public final void rule__MapTypeCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4005:1: ( ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) ) ) |
| // InternalEssentialOCL.g:4006:1: ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:4006:1: ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) ) |
| // InternalEssentialOCL.g:4007:1: ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeAssignment_1_1()); |
| } |
| // InternalEssentialOCL.g:4008:1: ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) |
| // InternalEssentialOCL.g:4008:2: rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__OwnedKeyTypeAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group_1__2" |
| // InternalEssentialOCL.g:4018:1: rule__MapTypeCS__Group_1__2 : rule__MapTypeCS__Group_1__2__Impl rule__MapTypeCS__Group_1__3 ; |
| public final void rule__MapTypeCS__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4022:1: ( rule__MapTypeCS__Group_1__2__Impl rule__MapTypeCS__Group_1__3 ) |
| // InternalEssentialOCL.g:4023:2: rule__MapTypeCS__Group_1__2__Impl rule__MapTypeCS__Group_1__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__MapTypeCS__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__Group_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group_1__2" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group_1__2__Impl" |
| // InternalEssentialOCL.g:4030:1: rule__MapTypeCS__Group_1__2__Impl : ( ',' ) ; |
| public final void rule__MapTypeCS__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4034:1: ( ( ',' ) ) |
| // InternalEssentialOCL.g:4035:1: ( ',' ) |
| { |
| // InternalEssentialOCL.g:4035:1: ( ',' ) |
| // InternalEssentialOCL.g:4036:1: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getCommaKeyword_1_2()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getCommaKeyword_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group_1__3" |
| // InternalEssentialOCL.g:4049:1: rule__MapTypeCS__Group_1__3 : rule__MapTypeCS__Group_1__3__Impl rule__MapTypeCS__Group_1__4 ; |
| public final void rule__MapTypeCS__Group_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4053:1: ( rule__MapTypeCS__Group_1__3__Impl rule__MapTypeCS__Group_1__4 ) |
| // InternalEssentialOCL.g:4054:2: rule__MapTypeCS__Group_1__3__Impl rule__MapTypeCS__Group_1__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_9); |
| rule__MapTypeCS__Group_1__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__Group_1__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group_1__3" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group_1__3__Impl" |
| // InternalEssentialOCL.g:4061:1: rule__MapTypeCS__Group_1__3__Impl : ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) ) ; |
| public final void rule__MapTypeCS__Group_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4065:1: ( ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) ) ) |
| // InternalEssentialOCL.g:4066:1: ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) ) |
| { |
| // InternalEssentialOCL.g:4066:1: ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) ) |
| // InternalEssentialOCL.g:4067:1: ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeAssignment_1_3()); |
| } |
| // InternalEssentialOCL.g:4068:1: ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) |
| // InternalEssentialOCL.g:4068:2: rule__MapTypeCS__OwnedValueTypeAssignment_1_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__OwnedValueTypeAssignment_1_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeAssignment_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group_1__4" |
| // InternalEssentialOCL.g:4078:1: rule__MapTypeCS__Group_1__4 : rule__MapTypeCS__Group_1__4__Impl ; |
| public final void rule__MapTypeCS__Group_1__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4082:1: ( rule__MapTypeCS__Group_1__4__Impl ) |
| // InternalEssentialOCL.g:4083:2: rule__MapTypeCS__Group_1__4__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapTypeCS__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__MapTypeCS__Group_1__4" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__Group_1__4__Impl" |
| // InternalEssentialOCL.g:4089:1: rule__MapTypeCS__Group_1__4__Impl : ( ')' ) ; |
| public final void rule__MapTypeCS__Group_1__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4093:1: ( ( ')' ) ) |
| // InternalEssentialOCL.g:4094:1: ( ')' ) |
| { |
| // InternalEssentialOCL.g:4094:1: ( ')' ) |
| // InternalEssentialOCL.g:4095:1: ')' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getRightParenthesisKeyword_1_4()); |
| } |
| match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getRightParenthesisKeyword_1_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__Group_1__4__Impl" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group__0" |
| // InternalEssentialOCL.g:4118:1: rule__TupleTypeCS__Group__0 : rule__TupleTypeCS__Group__0__Impl rule__TupleTypeCS__Group__1 ; |
| public final void rule__TupleTypeCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4122:1: ( rule__TupleTypeCS__Group__0__Impl rule__TupleTypeCS__Group__1 ) |
| // InternalEssentialOCL.g:4123:2: rule__TupleTypeCS__Group__0__Impl rule__TupleTypeCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_5); |
| rule__TupleTypeCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group__0" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group__0__Impl" |
| // InternalEssentialOCL.g:4130:1: rule__TupleTypeCS__Group__0__Impl : ( ( rule__TupleTypeCS__NameAssignment_0 ) ) ; |
| public final void rule__TupleTypeCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4134:1: ( ( ( rule__TupleTypeCS__NameAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:4135:1: ( ( rule__TupleTypeCS__NameAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:4135:1: ( ( rule__TupleTypeCS__NameAssignment_0 ) ) |
| // InternalEssentialOCL.g:4136:1: ( rule__TupleTypeCS__NameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:4137:1: ( rule__TupleTypeCS__NameAssignment_0 ) |
| // InternalEssentialOCL.g:4137:2: rule__TupleTypeCS__NameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__NameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group__1" |
| // InternalEssentialOCL.g:4147:1: rule__TupleTypeCS__Group__1 : rule__TupleTypeCS__Group__1__Impl ; |
| public final void rule__TupleTypeCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4151:1: ( rule__TupleTypeCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:4152:2: rule__TupleTypeCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group__1" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group__1__Impl" |
| // InternalEssentialOCL.g:4158:1: rule__TupleTypeCS__Group__1__Impl : ( ( rule__TupleTypeCS__Group_1__0 )? ) ; |
| public final void rule__TupleTypeCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4162:1: ( ( ( rule__TupleTypeCS__Group_1__0 )? ) ) |
| // InternalEssentialOCL.g:4163:1: ( ( rule__TupleTypeCS__Group_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:4163:1: ( ( rule__TupleTypeCS__Group_1__0 )? ) |
| // InternalEssentialOCL.g:4164:1: ( rule__TupleTypeCS__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:4165:1: ( rule__TupleTypeCS__Group_1__0 )? |
| int alt42=2; |
| int LA42_0 = input.LA(1); |
| |
| if ( (LA42_0==59) ) { |
| alt42=1; |
| } |
| switch (alt42) { |
| case 1 : |
| // InternalEssentialOCL.g:4165:2: rule__TupleTypeCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1__0" |
| // InternalEssentialOCL.g:4179:1: rule__TupleTypeCS__Group_1__0 : rule__TupleTypeCS__Group_1__0__Impl rule__TupleTypeCS__Group_1__1 ; |
| public final void rule__TupleTypeCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4183:1: ( rule__TupleTypeCS__Group_1__0__Impl rule__TupleTypeCS__Group_1__1 ) |
| // InternalEssentialOCL.g:4184:2: rule__TupleTypeCS__Group_1__0__Impl rule__TupleTypeCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_10); |
| rule__TupleTypeCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:4191:1: rule__TupleTypeCS__Group_1__0__Impl : ( '(' ) ; |
| public final void rule__TupleTypeCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4195:1: ( ( '(' ) ) |
| // InternalEssentialOCL.g:4196:1: ( '(' ) |
| { |
| // InternalEssentialOCL.g:4196:1: ( '(' ) |
| // InternalEssentialOCL.g:4197:1: '(' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getLeftParenthesisKeyword_1_0()); |
| } |
| match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getLeftParenthesisKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1__1" |
| // InternalEssentialOCL.g:4210:1: rule__TupleTypeCS__Group_1__1 : rule__TupleTypeCS__Group_1__1__Impl rule__TupleTypeCS__Group_1__2 ; |
| public final void rule__TupleTypeCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4214:1: ( rule__TupleTypeCS__Group_1__1__Impl rule__TupleTypeCS__Group_1__2 ) |
| // InternalEssentialOCL.g:4215:2: rule__TupleTypeCS__Group_1__1__Impl rule__TupleTypeCS__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_10); |
| rule__TupleTypeCS__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:4222:1: rule__TupleTypeCS__Group_1__1__Impl : ( ( rule__TupleTypeCS__Group_1_1__0 )? ) ; |
| public final void rule__TupleTypeCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4226:1: ( ( ( rule__TupleTypeCS__Group_1_1__0 )? ) ) |
| // InternalEssentialOCL.g:4227:1: ( ( rule__TupleTypeCS__Group_1_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:4227:1: ( ( rule__TupleTypeCS__Group_1_1__0 )? ) |
| // InternalEssentialOCL.g:4228:1: ( rule__TupleTypeCS__Group_1_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getGroup_1_1()); |
| } |
| // InternalEssentialOCL.g:4229:1: ( rule__TupleTypeCS__Group_1_1__0 )? |
| int alt43=2; |
| int LA43_0 = input.LA(1); |
| |
| if ( ((LA43_0>=RULE_SIMPLE_ID && LA43_0<=RULE_ESCAPED_ID)) ) { |
| alt43=1; |
| } |
| switch (alt43) { |
| case 1 : |
| // InternalEssentialOCL.g:4229:2: rule__TupleTypeCS__Group_1_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__Group_1_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getGroup_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1__2" |
| // InternalEssentialOCL.g:4239:1: rule__TupleTypeCS__Group_1__2 : rule__TupleTypeCS__Group_1__2__Impl ; |
| public final void rule__TupleTypeCS__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4243:1: ( rule__TupleTypeCS__Group_1__2__Impl ) |
| // InternalEssentialOCL.g:4244:2: rule__TupleTypeCS__Group_1__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__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__TupleTypeCS__Group_1__2" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1__2__Impl" |
| // InternalEssentialOCL.g:4250:1: rule__TupleTypeCS__Group_1__2__Impl : ( ')' ) ; |
| public final void rule__TupleTypeCS__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4254:1: ( ( ')' ) ) |
| // InternalEssentialOCL.g:4255:1: ( ')' ) |
| { |
| // InternalEssentialOCL.g:4255:1: ( ')' ) |
| // InternalEssentialOCL.g:4256:1: ')' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getRightParenthesisKeyword_1_2()); |
| } |
| match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getRightParenthesisKeyword_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1_1__0" |
| // InternalEssentialOCL.g:4275:1: rule__TupleTypeCS__Group_1_1__0 : rule__TupleTypeCS__Group_1_1__0__Impl rule__TupleTypeCS__Group_1_1__1 ; |
| public final void rule__TupleTypeCS__Group_1_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4279:1: ( rule__TupleTypeCS__Group_1_1__0__Impl rule__TupleTypeCS__Group_1_1__1 ) |
| // InternalEssentialOCL.g:4280:2: rule__TupleTypeCS__Group_1_1__0__Impl rule__TupleTypeCS__Group_1_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_8); |
| rule__TupleTypeCS__Group_1_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__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__TupleTypeCS__Group_1_1__0" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1_1__0__Impl" |
| // InternalEssentialOCL.g:4287:1: rule__TupleTypeCS__Group_1_1__0__Impl : ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) ) ; |
| public final void rule__TupleTypeCS__Group_1_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4291:1: ( ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) ) ) |
| // InternalEssentialOCL.g:4292:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) ) |
| { |
| // InternalEssentialOCL.g:4292:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) ) |
| // InternalEssentialOCL.g:4293:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_0()); |
| } |
| // InternalEssentialOCL.g:4294:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) |
| // InternalEssentialOCL.g:4294:2: rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__OwnedPartsAssignment_1_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group_1_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1_1__1" |
| // InternalEssentialOCL.g:4304:1: rule__TupleTypeCS__Group_1_1__1 : rule__TupleTypeCS__Group_1_1__1__Impl ; |
| public final void rule__TupleTypeCS__Group_1_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4308:1: ( rule__TupleTypeCS__Group_1_1__1__Impl ) |
| // InternalEssentialOCL.g:4309:2: rule__TupleTypeCS__Group_1_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__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__TupleTypeCS__Group_1_1__1" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1_1__1__Impl" |
| // InternalEssentialOCL.g:4315:1: rule__TupleTypeCS__Group_1_1__1__Impl : ( ( rule__TupleTypeCS__Group_1_1_1__0 )* ) ; |
| public final void rule__TupleTypeCS__Group_1_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4319:1: ( ( ( rule__TupleTypeCS__Group_1_1_1__0 )* ) ) |
| // InternalEssentialOCL.g:4320:1: ( ( rule__TupleTypeCS__Group_1_1_1__0 )* ) |
| { |
| // InternalEssentialOCL.g:4320:1: ( ( rule__TupleTypeCS__Group_1_1_1__0 )* ) |
| // InternalEssentialOCL.g:4321:1: ( rule__TupleTypeCS__Group_1_1_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getGroup_1_1_1()); |
| } |
| // InternalEssentialOCL.g:4322:1: ( rule__TupleTypeCS__Group_1_1_1__0 )* |
| loop44: |
| do { |
| int alt44=2; |
| int LA44_0 = input.LA(1); |
| |
| if ( (LA44_0==61) ) { |
| alt44=1; |
| } |
| |
| |
| switch (alt44) { |
| case 1 : |
| // InternalEssentialOCL.g:4322:2: rule__TupleTypeCS__Group_1_1_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_11); |
| rule__TupleTypeCS__Group_1_1_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop44; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getGroup_1_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group_1_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__0" |
| // InternalEssentialOCL.g:4336:1: rule__TupleTypeCS__Group_1_1_1__0 : rule__TupleTypeCS__Group_1_1_1__0__Impl rule__TupleTypeCS__Group_1_1_1__1 ; |
| public final void rule__TupleTypeCS__Group_1_1_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4340:1: ( rule__TupleTypeCS__Group_1_1_1__0__Impl rule__TupleTypeCS__Group_1_1_1__1 ) |
| // InternalEssentialOCL.g:4341:2: rule__TupleTypeCS__Group_1_1_1__0__Impl rule__TupleTypeCS__Group_1_1_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__TupleTypeCS__Group_1_1_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__Group_1_1_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group_1_1_1__0" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__0__Impl" |
| // InternalEssentialOCL.g:4348:1: rule__TupleTypeCS__Group_1_1_1__0__Impl : ( ',' ) ; |
| public final void rule__TupleTypeCS__Group_1_1_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4352:1: ( ( ',' ) ) |
| // InternalEssentialOCL.g:4353:1: ( ',' ) |
| { |
| // InternalEssentialOCL.g:4353:1: ( ',' ) |
| // InternalEssentialOCL.g:4354:1: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getCommaKeyword_1_1_1_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getCommaKeyword_1_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group_1_1_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__1" |
| // InternalEssentialOCL.g:4367:1: rule__TupleTypeCS__Group_1_1_1__1 : rule__TupleTypeCS__Group_1_1_1__1__Impl ; |
| public final void rule__TupleTypeCS__Group_1_1_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4371:1: ( rule__TupleTypeCS__Group_1_1_1__1__Impl ) |
| // InternalEssentialOCL.g:4372:2: rule__TupleTypeCS__Group_1_1_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__Group_1_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__TupleTypeCS__Group_1_1_1__1" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__1__Impl" |
| // InternalEssentialOCL.g:4378:1: rule__TupleTypeCS__Group_1_1_1__1__Impl : ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) ) ; |
| public final void rule__TupleTypeCS__Group_1_1_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4382:1: ( ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) ) ) |
| // InternalEssentialOCL.g:4383:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:4383:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) ) |
| // InternalEssentialOCL.g:4384:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_1_1()); |
| } |
| // InternalEssentialOCL.g:4385:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) |
| // InternalEssentialOCL.g:4385:2: rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__Group_1_1_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__TuplePartCS__Group__0" |
| // InternalEssentialOCL.g:4399:1: rule__TuplePartCS__Group__0 : rule__TuplePartCS__Group__0__Impl rule__TuplePartCS__Group__1 ; |
| public final void rule__TuplePartCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4403:1: ( rule__TuplePartCS__Group__0__Impl rule__TuplePartCS__Group__1 ) |
| // InternalEssentialOCL.g:4404:2: rule__TuplePartCS__Group__0__Impl rule__TuplePartCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__TuplePartCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TuplePartCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TuplePartCS__Group__0" |
| |
| |
| // $ANTLR start "rule__TuplePartCS__Group__0__Impl" |
| // InternalEssentialOCL.g:4411:1: rule__TuplePartCS__Group__0__Impl : ( ( rule__TuplePartCS__NameAssignment_0 ) ) ; |
| public final void rule__TuplePartCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4415:1: ( ( ( rule__TuplePartCS__NameAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:4416:1: ( ( rule__TuplePartCS__NameAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:4416:1: ( ( rule__TuplePartCS__NameAssignment_0 ) ) |
| // InternalEssentialOCL.g:4417:1: ( rule__TuplePartCS__NameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTuplePartCSAccess().getNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:4418:1: ( rule__TuplePartCS__NameAssignment_0 ) |
| // InternalEssentialOCL.g:4418:2: rule__TuplePartCS__NameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TuplePartCS__NameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTuplePartCSAccess().getNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TuplePartCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TuplePartCS__Group__1" |
| // InternalEssentialOCL.g:4428:1: rule__TuplePartCS__Group__1 : rule__TuplePartCS__Group__1__Impl rule__TuplePartCS__Group__2 ; |
| public final void rule__TuplePartCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4432:1: ( rule__TuplePartCS__Group__1__Impl rule__TuplePartCS__Group__2 ) |
| // InternalEssentialOCL.g:4433:2: rule__TuplePartCS__Group__1__Impl rule__TuplePartCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__TuplePartCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TuplePartCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TuplePartCS__Group__1" |
| |
| |
| // $ANTLR start "rule__TuplePartCS__Group__1__Impl" |
| // InternalEssentialOCL.g:4440:1: rule__TuplePartCS__Group__1__Impl : ( ':' ) ; |
| public final void rule__TuplePartCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4444:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:4445:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:4445:1: ( ':' ) |
| // InternalEssentialOCL.g:4446:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTuplePartCSAccess().getColonKeyword_1()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTuplePartCSAccess().getColonKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TuplePartCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TuplePartCS__Group__2" |
| // InternalEssentialOCL.g:4459:1: rule__TuplePartCS__Group__2 : rule__TuplePartCS__Group__2__Impl ; |
| public final void rule__TuplePartCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4463:1: ( rule__TuplePartCS__Group__2__Impl ) |
| // InternalEssentialOCL.g:4464:2: rule__TuplePartCS__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TuplePartCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TuplePartCS__Group__2" |
| |
| |
| // $ANTLR start "rule__TuplePartCS__Group__2__Impl" |
| // InternalEssentialOCL.g:4470:1: rule__TuplePartCS__Group__2__Impl : ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) ) ; |
| public final void rule__TuplePartCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4474:1: ( ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) ) ) |
| // InternalEssentialOCL.g:4475:1: ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) ) |
| { |
| // InternalEssentialOCL.g:4475:1: ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) ) |
| // InternalEssentialOCL.g:4476:1: ( rule__TuplePartCS__OwnedTypeAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTuplePartCSAccess().getOwnedTypeAssignment_2()); |
| } |
| // InternalEssentialOCL.g:4477:1: ( rule__TuplePartCS__OwnedTypeAssignment_2 ) |
| // InternalEssentialOCL.g:4477:2: rule__TuplePartCS__OwnedTypeAssignment_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TuplePartCS__OwnedTypeAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTuplePartCSAccess().getOwnedTypeAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TuplePartCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group__0" |
| // InternalEssentialOCL.g:4493:1: rule__CollectionLiteralExpCS__Group__0 : rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1 ; |
| public final void rule__CollectionLiteralExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4497:1: ( rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1 ) |
| // InternalEssentialOCL.g:4498:2: rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_14); |
| rule__CollectionLiteralExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:4505:1: rule__CollectionLiteralExpCS__Group__0__Impl : ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) ) ; |
| public final void rule__CollectionLiteralExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4509:1: ( ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:4510:1: ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:4510:1: ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) ) |
| // InternalEssentialOCL.g:4511:1: ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeAssignment_0()); |
| } |
| // InternalEssentialOCL.g:4512:1: ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) |
| // InternalEssentialOCL.g:4512:2: rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__OwnedTypeAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group__1" |
| // InternalEssentialOCL.g:4522:1: rule__CollectionLiteralExpCS__Group__1 : rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2 ; |
| public final void rule__CollectionLiteralExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4526:1: ( rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2 ) |
| // InternalEssentialOCL.g:4527:2: rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_15); |
| rule__CollectionLiteralExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:4534:1: rule__CollectionLiteralExpCS__Group__1__Impl : ( '{' ) ; |
| public final void rule__CollectionLiteralExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4538:1: ( ( '{' ) ) |
| // InternalEssentialOCL.g:4539:1: ( '{' ) |
| { |
| // InternalEssentialOCL.g:4539:1: ( '{' ) |
| // InternalEssentialOCL.g:4540:1: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group__2" |
| // InternalEssentialOCL.g:4553:1: rule__CollectionLiteralExpCS__Group__2 : rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3 ; |
| public final void rule__CollectionLiteralExpCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4557:1: ( rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3 ) |
| // InternalEssentialOCL.g:4558:2: rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_15); |
| rule__CollectionLiteralExpCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group__2" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group__2__Impl" |
| // InternalEssentialOCL.g:4565:1: rule__CollectionLiteralExpCS__Group__2__Impl : ( ( rule__CollectionLiteralExpCS__Group_2__0 )? ) ; |
| public final void rule__CollectionLiteralExpCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4569:1: ( ( ( rule__CollectionLiteralExpCS__Group_2__0 )? ) ) |
| // InternalEssentialOCL.g:4570:1: ( ( rule__CollectionLiteralExpCS__Group_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:4570:1: ( ( rule__CollectionLiteralExpCS__Group_2__0 )? ) |
| // InternalEssentialOCL.g:4571:1: ( rule__CollectionLiteralExpCS__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2()); |
| } |
| // InternalEssentialOCL.g:4572:1: ( rule__CollectionLiteralExpCS__Group_2__0 )? |
| int alt45=2; |
| int LA45_0 = input.LA(1); |
| |
| if ( ((LA45_0>=RULE_INT && LA45_0<=RULE_ESCAPED_ID)||(LA45_0>=16 && LA45_0<=19)||(LA45_0>=40 && LA45_0<=54)||LA45_0==59||LA45_0==62||(LA45_0>=67 && LA45_0<=69)||LA45_0==74||(LA45_0>=79 && LA45_0<=80)||(LA45_0>=84 && LA45_0<=85)) ) { |
| alt45=1; |
| } |
| switch (alt45) { |
| case 1 : |
| // InternalEssentialOCL.g:4572:2: rule__CollectionLiteralExpCS__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group__3" |
| // InternalEssentialOCL.g:4582:1: rule__CollectionLiteralExpCS__Group__3 : rule__CollectionLiteralExpCS__Group__3__Impl ; |
| public final void rule__CollectionLiteralExpCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4586:1: ( rule__CollectionLiteralExpCS__Group__3__Impl ) |
| // InternalEssentialOCL.g:4587:2: rule__CollectionLiteralExpCS__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group__3" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group__3__Impl" |
| // InternalEssentialOCL.g:4593:1: rule__CollectionLiteralExpCS__Group__3__Impl : ( '}' ) ; |
| public final void rule__CollectionLiteralExpCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4597:1: ( ( '}' ) ) |
| // InternalEssentialOCL.g:4598:1: ( '}' ) |
| { |
| // InternalEssentialOCL.g:4598:1: ( '}' ) |
| // InternalEssentialOCL.g:4599:1: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getRightCurlyBracketKeyword_3()); |
| } |
| match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getRightCurlyBracketKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__0" |
| // InternalEssentialOCL.g:4620:1: rule__CollectionLiteralExpCS__Group_2__0 : rule__CollectionLiteralExpCS__Group_2__0__Impl rule__CollectionLiteralExpCS__Group_2__1 ; |
| public final void rule__CollectionLiteralExpCS__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4624:1: ( rule__CollectionLiteralExpCS__Group_2__0__Impl rule__CollectionLiteralExpCS__Group_2__1 ) |
| // InternalEssentialOCL.g:4625:2: rule__CollectionLiteralExpCS__Group_2__0__Impl rule__CollectionLiteralExpCS__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_8); |
| rule__CollectionLiteralExpCS__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group_2__0" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__0__Impl" |
| // InternalEssentialOCL.g:4632:1: rule__CollectionLiteralExpCS__Group_2__0__Impl : ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) ) ; |
| public final void rule__CollectionLiteralExpCS__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4636:1: ( ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) ) ) |
| // InternalEssentialOCL.g:4637:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) ) |
| { |
| // InternalEssentialOCL.g:4637:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) ) |
| // InternalEssentialOCL.g:4638:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_0()); |
| } |
| // InternalEssentialOCL.g:4639:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) |
| // InternalEssentialOCL.g:4639:2: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__1" |
| // InternalEssentialOCL.g:4649:1: rule__CollectionLiteralExpCS__Group_2__1 : rule__CollectionLiteralExpCS__Group_2__1__Impl ; |
| public final void rule__CollectionLiteralExpCS__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4653:1: ( rule__CollectionLiteralExpCS__Group_2__1__Impl ) |
| // InternalEssentialOCL.g:4654:2: rule__CollectionLiteralExpCS__Group_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__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__CollectionLiteralExpCS__Group_2__1" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__1__Impl" |
| // InternalEssentialOCL.g:4660:1: rule__CollectionLiteralExpCS__Group_2__1__Impl : ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* ) ; |
| public final void rule__CollectionLiteralExpCS__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4664:1: ( ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* ) ) |
| // InternalEssentialOCL.g:4665:1: ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* ) |
| { |
| // InternalEssentialOCL.g:4665:1: ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* ) |
| // InternalEssentialOCL.g:4666:1: ( rule__CollectionLiteralExpCS__Group_2_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2_1()); |
| } |
| // InternalEssentialOCL.g:4667:1: ( rule__CollectionLiteralExpCS__Group_2_1__0 )* |
| loop46: |
| do { |
| int alt46=2; |
| int LA46_0 = input.LA(1); |
| |
| if ( (LA46_0==61) ) { |
| alt46=1; |
| } |
| |
| |
| switch (alt46) { |
| case 1 : |
| // InternalEssentialOCL.g:4667:2: rule__CollectionLiteralExpCS__Group_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_11); |
| rule__CollectionLiteralExpCS__Group_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop46; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__0" |
| // InternalEssentialOCL.g:4681:1: rule__CollectionLiteralExpCS__Group_2_1__0 : rule__CollectionLiteralExpCS__Group_2_1__0__Impl rule__CollectionLiteralExpCS__Group_2_1__1 ; |
| public final void rule__CollectionLiteralExpCS__Group_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4685:1: ( rule__CollectionLiteralExpCS__Group_2_1__0__Impl rule__CollectionLiteralExpCS__Group_2_1__1 ) |
| // InternalEssentialOCL.g:4686:2: rule__CollectionLiteralExpCS__Group_2_1__0__Impl rule__CollectionLiteralExpCS__Group_2_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_16); |
| rule__CollectionLiteralExpCS__Group_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__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__CollectionLiteralExpCS__Group_2_1__0" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__0__Impl" |
| // InternalEssentialOCL.g:4693:1: rule__CollectionLiteralExpCS__Group_2_1__0__Impl : ( ',' ) ; |
| public final void rule__CollectionLiteralExpCS__Group_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4697:1: ( ( ',' ) ) |
| // InternalEssentialOCL.g:4698:1: ( ',' ) |
| { |
| // InternalEssentialOCL.g:4698:1: ( ',' ) |
| // InternalEssentialOCL.g:4699:1: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getCommaKeyword_2_1_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getCommaKeyword_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__1" |
| // InternalEssentialOCL.g:4712:1: rule__CollectionLiteralExpCS__Group_2_1__1 : rule__CollectionLiteralExpCS__Group_2_1__1__Impl ; |
| public final void rule__CollectionLiteralExpCS__Group_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4716:1: ( rule__CollectionLiteralExpCS__Group_2_1__1__Impl ) |
| // InternalEssentialOCL.g:4717:2: rule__CollectionLiteralExpCS__Group_2_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__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__CollectionLiteralExpCS__Group_2_1__1" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__1__Impl" |
| // InternalEssentialOCL.g:4723:1: rule__CollectionLiteralExpCS__Group_2_1__1__Impl : ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) ; |
| public final void rule__CollectionLiteralExpCS__Group_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4727:1: ( ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) ) |
| // InternalEssentialOCL.g:4728:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:4728:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) |
| // InternalEssentialOCL.g:4729:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1()); |
| } |
| // InternalEssentialOCL.g:4730:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) |
| // InternalEssentialOCL.g:4730:2: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__Group_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__0" |
| // InternalEssentialOCL.g:4744:1: rule__CollectionLiteralPartCS__Group_0__0 : rule__CollectionLiteralPartCS__Group_0__0__Impl rule__CollectionLiteralPartCS__Group_0__1 ; |
| public final void rule__CollectionLiteralPartCS__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4748:1: ( rule__CollectionLiteralPartCS__Group_0__0__Impl rule__CollectionLiteralPartCS__Group_0__1 ) |
| // InternalEssentialOCL.g:4749:2: rule__CollectionLiteralPartCS__Group_0__0__Impl rule__CollectionLiteralPartCS__Group_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_17); |
| rule__CollectionLiteralPartCS__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralPartCS__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralPartCS__Group_0__0" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__0__Impl" |
| // InternalEssentialOCL.g:4756:1: rule__CollectionLiteralPartCS__Group_0__0__Impl : ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) ) ; |
| public final void rule__CollectionLiteralPartCS__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4760:1: ( ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) ) ) |
| // InternalEssentialOCL.g:4761:1: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) ) |
| { |
| // InternalEssentialOCL.g:4761:1: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) ) |
| // InternalEssentialOCL.g:4762:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_0_0()); |
| } |
| // InternalEssentialOCL.g:4763:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) |
| // InternalEssentialOCL.g:4763:2: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralPartCS__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__1" |
| // InternalEssentialOCL.g:4773:1: rule__CollectionLiteralPartCS__Group_0__1 : rule__CollectionLiteralPartCS__Group_0__1__Impl ; |
| public final void rule__CollectionLiteralPartCS__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4777:1: ( rule__CollectionLiteralPartCS__Group_0__1__Impl ) |
| // InternalEssentialOCL.g:4778:2: rule__CollectionLiteralPartCS__Group_0__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralPartCS__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__CollectionLiteralPartCS__Group_0__1" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__1__Impl" |
| // InternalEssentialOCL.g:4784:1: rule__CollectionLiteralPartCS__Group_0__1__Impl : ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? ) ; |
| public final void rule__CollectionLiteralPartCS__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4788:1: ( ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? ) ) |
| // InternalEssentialOCL.g:4789:1: ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:4789:1: ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? ) |
| // InternalEssentialOCL.g:4790:1: ( rule__CollectionLiteralPartCS__Group_0_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0_1()); |
| } |
| // InternalEssentialOCL.g:4791:1: ( rule__CollectionLiteralPartCS__Group_0_1__0 )? |
| int alt47=2; |
| int LA47_0 = input.LA(1); |
| |
| if ( (LA47_0==65) ) { |
| alt47=1; |
| } |
| switch (alt47) { |
| case 1 : |
| // InternalEssentialOCL.g:4791:2: rule__CollectionLiteralPartCS__Group_0_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralPartCS__Group_0_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralPartCS__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__0" |
| // InternalEssentialOCL.g:4805:1: rule__CollectionLiteralPartCS__Group_0_1__0 : rule__CollectionLiteralPartCS__Group_0_1__0__Impl rule__CollectionLiteralPartCS__Group_0_1__1 ; |
| public final void rule__CollectionLiteralPartCS__Group_0_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4809:1: ( rule__CollectionLiteralPartCS__Group_0_1__0__Impl rule__CollectionLiteralPartCS__Group_0_1__1 ) |
| // InternalEssentialOCL.g:4810:2: rule__CollectionLiteralPartCS__Group_0_1__0__Impl rule__CollectionLiteralPartCS__Group_0_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__CollectionLiteralPartCS__Group_0_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralPartCS__Group_0_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__0" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__0__Impl" |
| // InternalEssentialOCL.g:4817:1: rule__CollectionLiteralPartCS__Group_0_1__0__Impl : ( '..' ) ; |
| public final void rule__CollectionLiteralPartCS__Group_0_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4821:1: ( ( '..' ) ) |
| // InternalEssentialOCL.g:4822:1: ( '..' ) |
| { |
| // InternalEssentialOCL.g:4822:1: ( '..' ) |
| // InternalEssentialOCL.g:4823:1: '..' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralPartCSAccess().getFullStopFullStopKeyword_0_1_0()); |
| } |
| match(input,65,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralPartCSAccess().getFullStopFullStopKeyword_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__1" |
| // InternalEssentialOCL.g:4836:1: rule__CollectionLiteralPartCS__Group_0_1__1 : rule__CollectionLiteralPartCS__Group_0_1__1__Impl ; |
| public final void rule__CollectionLiteralPartCS__Group_0_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4840:1: ( rule__CollectionLiteralPartCS__Group_0_1__1__Impl ) |
| // InternalEssentialOCL.g:4841:2: rule__CollectionLiteralPartCS__Group_0_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralPartCS__Group_0_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__1" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__1__Impl" |
| // InternalEssentialOCL.g:4847:1: rule__CollectionLiteralPartCS__Group_0_1__1__Impl : ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) ) ; |
| public final void rule__CollectionLiteralPartCS__Group_0_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4851:1: ( ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) ) ) |
| // InternalEssentialOCL.g:4852:1: ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:4852:1: ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) ) |
| // InternalEssentialOCL.g:4853:1: ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionAssignment_0_1_1()); |
| } |
| // InternalEssentialOCL.g:4854:1: ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) |
| // InternalEssentialOCL.g:4854:2: rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionAssignment_0_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group__0" |
| // InternalEssentialOCL.g:4868:1: rule__CollectionPatternCS__Group__0 : rule__CollectionPatternCS__Group__0__Impl rule__CollectionPatternCS__Group__1 ; |
| public final void rule__CollectionPatternCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4872:1: ( rule__CollectionPatternCS__Group__0__Impl rule__CollectionPatternCS__Group__1 ) |
| // InternalEssentialOCL.g:4873:2: rule__CollectionPatternCS__Group__0__Impl rule__CollectionPatternCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_14); |
| rule__CollectionPatternCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group__0" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group__0__Impl" |
| // InternalEssentialOCL.g:4880:1: rule__CollectionPatternCS__Group__0__Impl : ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) ) ; |
| public final void rule__CollectionPatternCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4884:1: ( ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:4885:1: ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:4885:1: ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) ) |
| // InternalEssentialOCL.g:4886:1: ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeAssignment_0()); |
| } |
| // InternalEssentialOCL.g:4887:1: ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) |
| // InternalEssentialOCL.g:4887:2: rule__CollectionPatternCS__OwnedTypeAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__OwnedTypeAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group__1" |
| // InternalEssentialOCL.g:4897:1: rule__CollectionPatternCS__Group__1 : rule__CollectionPatternCS__Group__1__Impl rule__CollectionPatternCS__Group__2 ; |
| public final void rule__CollectionPatternCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4901:1: ( rule__CollectionPatternCS__Group__1__Impl rule__CollectionPatternCS__Group__2 ) |
| // InternalEssentialOCL.g:4902:2: rule__CollectionPatternCS__Group__1__Impl rule__CollectionPatternCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_15); |
| rule__CollectionPatternCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group__1" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group__1__Impl" |
| // InternalEssentialOCL.g:4909:1: rule__CollectionPatternCS__Group__1__Impl : ( '{' ) ; |
| public final void rule__CollectionPatternCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4913:1: ( ( '{' ) ) |
| // InternalEssentialOCL.g:4914:1: ( '{' ) |
| { |
| // InternalEssentialOCL.g:4914:1: ( '{' ) |
| // InternalEssentialOCL.g:4915:1: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group__2" |
| // InternalEssentialOCL.g:4928:1: rule__CollectionPatternCS__Group__2 : rule__CollectionPatternCS__Group__2__Impl rule__CollectionPatternCS__Group__3 ; |
| public final void rule__CollectionPatternCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4932:1: ( rule__CollectionPatternCS__Group__2__Impl rule__CollectionPatternCS__Group__3 ) |
| // InternalEssentialOCL.g:4933:2: rule__CollectionPatternCS__Group__2__Impl rule__CollectionPatternCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_15); |
| rule__CollectionPatternCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group__2" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group__2__Impl" |
| // InternalEssentialOCL.g:4940:1: rule__CollectionPatternCS__Group__2__Impl : ( ( rule__CollectionPatternCS__Group_2__0 )? ) ; |
| public final void rule__CollectionPatternCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4944:1: ( ( ( rule__CollectionPatternCS__Group_2__0 )? ) ) |
| // InternalEssentialOCL.g:4945:1: ( ( rule__CollectionPatternCS__Group_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:4945:1: ( ( rule__CollectionPatternCS__Group_2__0 )? ) |
| // InternalEssentialOCL.g:4946:1: ( rule__CollectionPatternCS__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getGroup_2()); |
| } |
| // InternalEssentialOCL.g:4947:1: ( rule__CollectionPatternCS__Group_2__0 )? |
| int alt48=2; |
| int LA48_0 = input.LA(1); |
| |
| if ( ((LA48_0>=RULE_SIMPLE_ID && LA48_0<=RULE_ESCAPED_ID)||LA48_0==62) ) { |
| alt48=1; |
| } |
| switch (alt48) { |
| case 1 : |
| // InternalEssentialOCL.g:4947:2: rule__CollectionPatternCS__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group__3" |
| // InternalEssentialOCL.g:4957:1: rule__CollectionPatternCS__Group__3 : rule__CollectionPatternCS__Group__3__Impl ; |
| public final void rule__CollectionPatternCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4961:1: ( rule__CollectionPatternCS__Group__3__Impl ) |
| // InternalEssentialOCL.g:4962:2: rule__CollectionPatternCS__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group__3" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group__3__Impl" |
| // InternalEssentialOCL.g:4968:1: rule__CollectionPatternCS__Group__3__Impl : ( '}' ) ; |
| public final void rule__CollectionPatternCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4972:1: ( ( '}' ) ) |
| // InternalEssentialOCL.g:4973:1: ( '}' ) |
| { |
| // InternalEssentialOCL.g:4973:1: ( '}' ) |
| // InternalEssentialOCL.g:4974:1: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getRightCurlyBracketKeyword_3()); |
| } |
| match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getRightCurlyBracketKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2__0" |
| // InternalEssentialOCL.g:4995:1: rule__CollectionPatternCS__Group_2__0 : rule__CollectionPatternCS__Group_2__0__Impl rule__CollectionPatternCS__Group_2__1 ; |
| public final void rule__CollectionPatternCS__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:4999:1: ( rule__CollectionPatternCS__Group_2__0__Impl rule__CollectionPatternCS__Group_2__1 ) |
| // InternalEssentialOCL.g:5000:2: rule__CollectionPatternCS__Group_2__0__Impl rule__CollectionPatternCS__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_19); |
| rule__CollectionPatternCS__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group_2__0" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2__0__Impl" |
| // InternalEssentialOCL.g:5007:1: rule__CollectionPatternCS__Group_2__0__Impl : ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) ) ; |
| public final void rule__CollectionPatternCS__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5011:1: ( ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) ) ) |
| // InternalEssentialOCL.g:5012:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) ) |
| { |
| // InternalEssentialOCL.g:5012:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) ) |
| // InternalEssentialOCL.g:5013:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_0()); |
| } |
| // InternalEssentialOCL.g:5014:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) |
| // InternalEssentialOCL.g:5014:2: rule__CollectionPatternCS__OwnedPartsAssignment_2_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__OwnedPartsAssignment_2_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2__1" |
| // InternalEssentialOCL.g:5024:1: rule__CollectionPatternCS__Group_2__1 : rule__CollectionPatternCS__Group_2__1__Impl rule__CollectionPatternCS__Group_2__2 ; |
| public final void rule__CollectionPatternCS__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5028:1: ( rule__CollectionPatternCS__Group_2__1__Impl rule__CollectionPatternCS__Group_2__2 ) |
| // InternalEssentialOCL.g:5029:2: rule__CollectionPatternCS__Group_2__1__Impl rule__CollectionPatternCS__Group_2__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_19); |
| rule__CollectionPatternCS__Group_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__Group_2__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group_2__1" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2__1__Impl" |
| // InternalEssentialOCL.g:5036:1: rule__CollectionPatternCS__Group_2__1__Impl : ( ( rule__CollectionPatternCS__Group_2_1__0 )* ) ; |
| public final void rule__CollectionPatternCS__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5040:1: ( ( ( rule__CollectionPatternCS__Group_2_1__0 )* ) ) |
| // InternalEssentialOCL.g:5041:1: ( ( rule__CollectionPatternCS__Group_2_1__0 )* ) |
| { |
| // InternalEssentialOCL.g:5041:1: ( ( rule__CollectionPatternCS__Group_2_1__0 )* ) |
| // InternalEssentialOCL.g:5042:1: ( rule__CollectionPatternCS__Group_2_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getGroup_2_1()); |
| } |
| // InternalEssentialOCL.g:5043:1: ( rule__CollectionPatternCS__Group_2_1__0 )* |
| loop49: |
| do { |
| int alt49=2; |
| int LA49_0 = input.LA(1); |
| |
| if ( (LA49_0==61) ) { |
| alt49=1; |
| } |
| |
| |
| switch (alt49) { |
| case 1 : |
| // InternalEssentialOCL.g:5043:2: rule__CollectionPatternCS__Group_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_11); |
| rule__CollectionPatternCS__Group_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop49; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getGroup_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2__2" |
| // InternalEssentialOCL.g:5053:1: rule__CollectionPatternCS__Group_2__2 : rule__CollectionPatternCS__Group_2__2__Impl ; |
| public final void rule__CollectionPatternCS__Group_2__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5057:1: ( rule__CollectionPatternCS__Group_2__2__Impl ) |
| // InternalEssentialOCL.g:5058:2: rule__CollectionPatternCS__Group_2__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__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__CollectionPatternCS__Group_2__2" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2__2__Impl" |
| // InternalEssentialOCL.g:5064:1: rule__CollectionPatternCS__Group_2__2__Impl : ( ( rule__CollectionPatternCS__Group_2_2__0 ) ) ; |
| public final void rule__CollectionPatternCS__Group_2__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5068:1: ( ( ( rule__CollectionPatternCS__Group_2_2__0 ) ) ) |
| // InternalEssentialOCL.g:5069:1: ( ( rule__CollectionPatternCS__Group_2_2__0 ) ) |
| { |
| // InternalEssentialOCL.g:5069:1: ( ( rule__CollectionPatternCS__Group_2_2__0 ) ) |
| // InternalEssentialOCL.g:5070:1: ( rule__CollectionPatternCS__Group_2_2__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getGroup_2_2()); |
| } |
| // InternalEssentialOCL.g:5071:1: ( rule__CollectionPatternCS__Group_2_2__0 ) |
| // InternalEssentialOCL.g:5071:2: rule__CollectionPatternCS__Group_2_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__Group_2_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getGroup_2_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group_2__2__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2_1__0" |
| // InternalEssentialOCL.g:5087:1: rule__CollectionPatternCS__Group_2_1__0 : rule__CollectionPatternCS__Group_2_1__0__Impl rule__CollectionPatternCS__Group_2_1__1 ; |
| public final void rule__CollectionPatternCS__Group_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5091:1: ( rule__CollectionPatternCS__Group_2_1__0__Impl rule__CollectionPatternCS__Group_2_1__1 ) |
| // InternalEssentialOCL.g:5092:2: rule__CollectionPatternCS__Group_2_1__0__Impl rule__CollectionPatternCS__Group_2_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_16); |
| rule__CollectionPatternCS__Group_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__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__CollectionPatternCS__Group_2_1__0" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2_1__0__Impl" |
| // InternalEssentialOCL.g:5099:1: rule__CollectionPatternCS__Group_2_1__0__Impl : ( ',' ) ; |
| public final void rule__CollectionPatternCS__Group_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5103:1: ( ( ',' ) ) |
| // InternalEssentialOCL.g:5104:1: ( ',' ) |
| { |
| // InternalEssentialOCL.g:5104:1: ( ',' ) |
| // InternalEssentialOCL.g:5105:1: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getCommaKeyword_2_1_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getCommaKeyword_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2_1__1" |
| // InternalEssentialOCL.g:5118:1: rule__CollectionPatternCS__Group_2_1__1 : rule__CollectionPatternCS__Group_2_1__1__Impl ; |
| public final void rule__CollectionPatternCS__Group_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5122:1: ( rule__CollectionPatternCS__Group_2_1__1__Impl ) |
| // InternalEssentialOCL.g:5123:2: rule__CollectionPatternCS__Group_2_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__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__CollectionPatternCS__Group_2_1__1" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2_1__1__Impl" |
| // InternalEssentialOCL.g:5129:1: rule__CollectionPatternCS__Group_2_1__1__Impl : ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) ) ; |
| public final void rule__CollectionPatternCS__Group_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5133:1: ( ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) ) ) |
| // InternalEssentialOCL.g:5134:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:5134:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) ) |
| // InternalEssentialOCL.g:5135:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_1_1()); |
| } |
| // InternalEssentialOCL.g:5136:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) |
| // InternalEssentialOCL.g:5136:2: rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2_2__0" |
| // InternalEssentialOCL.g:5150:1: rule__CollectionPatternCS__Group_2_2__0 : rule__CollectionPatternCS__Group_2_2__0__Impl rule__CollectionPatternCS__Group_2_2__1 ; |
| public final void rule__CollectionPatternCS__Group_2_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5154:1: ( rule__CollectionPatternCS__Group_2_2__0__Impl rule__CollectionPatternCS__Group_2_2__1 ) |
| // InternalEssentialOCL.g:5155:2: rule__CollectionPatternCS__Group_2_2__0__Impl rule__CollectionPatternCS__Group_2_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__CollectionPatternCS__Group_2_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__Group_2_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group_2_2__0" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2_2__0__Impl" |
| // InternalEssentialOCL.g:5162:1: rule__CollectionPatternCS__Group_2_2__0__Impl : ( '++' ) ; |
| public final void rule__CollectionPatternCS__Group_2_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5166:1: ( ( '++' ) ) |
| // InternalEssentialOCL.g:5167:1: ( '++' ) |
| { |
| // InternalEssentialOCL.g:5167:1: ( '++' ) |
| // InternalEssentialOCL.g:5168:1: '++' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getPlusSignPlusSignKeyword_2_2_0()); |
| } |
| match(input,66,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getPlusSignPlusSignKeyword_2_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group_2_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2_2__1" |
| // InternalEssentialOCL.g:5181:1: rule__CollectionPatternCS__Group_2_2__1 : rule__CollectionPatternCS__Group_2_2__1__Impl ; |
| public final void rule__CollectionPatternCS__Group_2_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5185:1: ( rule__CollectionPatternCS__Group_2_2__1__Impl ) |
| // InternalEssentialOCL.g:5186:2: rule__CollectionPatternCS__Group_2_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__Group_2_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group_2_2__1" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__Group_2_2__1__Impl" |
| // InternalEssentialOCL.g:5192:1: rule__CollectionPatternCS__Group_2_2__1__Impl : ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) ) ; |
| public final void rule__CollectionPatternCS__Group_2_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5196:1: ( ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) ) ) |
| // InternalEssentialOCL.g:5197:1: ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:5197:1: ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) ) |
| // InternalEssentialOCL.g:5198:1: ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameAssignment_2_2_1()); |
| } |
| // InternalEssentialOCL.g:5199:1: ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) |
| // InternalEssentialOCL.g:5199:2: rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameAssignment_2_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__Group_2_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__ShadowPartCS__Group_0__0" |
| // InternalEssentialOCL.g:5213:1: rule__ShadowPartCS__Group_0__0 : rule__ShadowPartCS__Group_0__0__Impl rule__ShadowPartCS__Group_0__1 ; |
| public final void rule__ShadowPartCS__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5217:1: ( rule__ShadowPartCS__Group_0__0__Impl rule__ShadowPartCS__Group_0__1 ) |
| // InternalEssentialOCL.g:5218:2: rule__ShadowPartCS__Group_0__0__Impl rule__ShadowPartCS__Group_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__ShadowPartCS__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ShadowPartCS__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ShadowPartCS__Group_0__0" |
| |
| |
| // $ANTLR start "rule__ShadowPartCS__Group_0__0__Impl" |
| // InternalEssentialOCL.g:5225:1: rule__ShadowPartCS__Group_0__0__Impl : ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) ) ; |
| public final void rule__ShadowPartCS__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5229:1: ( ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) ) ) |
| // InternalEssentialOCL.g:5230:1: ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) ) |
| { |
| // InternalEssentialOCL.g:5230:1: ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) ) |
| // InternalEssentialOCL.g:5231:1: ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getReferredPropertyAssignment_0_0()); |
| } |
| // InternalEssentialOCL.g:5232:1: ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) |
| // InternalEssentialOCL.g:5232:2: rule__ShadowPartCS__ReferredPropertyAssignment_0_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ShadowPartCS__ReferredPropertyAssignment_0_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getReferredPropertyAssignment_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ShadowPartCS__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__ShadowPartCS__Group_0__1" |
| // InternalEssentialOCL.g:5242:1: rule__ShadowPartCS__Group_0__1 : rule__ShadowPartCS__Group_0__1__Impl rule__ShadowPartCS__Group_0__2 ; |
| public final void rule__ShadowPartCS__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5246:1: ( rule__ShadowPartCS__Group_0__1__Impl rule__ShadowPartCS__Group_0__2 ) |
| // InternalEssentialOCL.g:5247:2: rule__ShadowPartCS__Group_0__1__Impl rule__ShadowPartCS__Group_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_16); |
| rule__ShadowPartCS__Group_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ShadowPartCS__Group_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ShadowPartCS__Group_0__1" |
| |
| |
| // $ANTLR start "rule__ShadowPartCS__Group_0__1__Impl" |
| // InternalEssentialOCL.g:5254:1: rule__ShadowPartCS__Group_0__1__Impl : ( '=' ) ; |
| public final void rule__ShadowPartCS__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5258:1: ( ( '=' ) ) |
| // InternalEssentialOCL.g:5259:1: ( '=' ) |
| { |
| // InternalEssentialOCL.g:5259:1: ( '=' ) |
| // InternalEssentialOCL.g:5260:1: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getEqualsSignKeyword_0_1()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getEqualsSignKeyword_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ShadowPartCS__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__ShadowPartCS__Group_0__2" |
| // InternalEssentialOCL.g:5273:1: rule__ShadowPartCS__Group_0__2 : rule__ShadowPartCS__Group_0__2__Impl ; |
| public final void rule__ShadowPartCS__Group_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5277:1: ( rule__ShadowPartCS__Group_0__2__Impl ) |
| // InternalEssentialOCL.g:5278:2: rule__ShadowPartCS__Group_0__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ShadowPartCS__Group_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ShadowPartCS__Group_0__2" |
| |
| |
| // $ANTLR start "rule__ShadowPartCS__Group_0__2__Impl" |
| // InternalEssentialOCL.g:5284:1: rule__ShadowPartCS__Group_0__2__Impl : ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) ) ; |
| public final void rule__ShadowPartCS__Group_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5288:1: ( ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) ) ) |
| // InternalEssentialOCL.g:5289:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) ) |
| { |
| // InternalEssentialOCL.g:5289:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) ) |
| // InternalEssentialOCL.g:5290:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_0_2()); |
| } |
| // InternalEssentialOCL.g:5291:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) |
| // InternalEssentialOCL.g:5291:2: rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ShadowPartCS__Group_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__PatternExpCS__Group__0" |
| // InternalEssentialOCL.g:5307:1: rule__PatternExpCS__Group__0 : rule__PatternExpCS__Group__0__Impl rule__PatternExpCS__Group__1 ; |
| public final void rule__PatternExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5311:1: ( rule__PatternExpCS__Group__0__Impl rule__PatternExpCS__Group__1 ) |
| // InternalEssentialOCL.g:5312:2: rule__PatternExpCS__Group__0__Impl rule__PatternExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_16); |
| rule__PatternExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PatternExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PatternExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__PatternExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:5319:1: rule__PatternExpCS__Group__0__Impl : ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? ) ; |
| public final void rule__PatternExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5323:1: ( ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? ) ) |
| // InternalEssentialOCL.g:5324:1: ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? ) |
| { |
| // InternalEssentialOCL.g:5324:1: ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? ) |
| // InternalEssentialOCL.g:5325:1: ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPatternExpCSAccess().getPatternVariableNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:5326:1: ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? |
| int alt50=2; |
| int LA50_0 = input.LA(1); |
| |
| if ( ((LA50_0>=RULE_SIMPLE_ID && LA50_0<=RULE_ESCAPED_ID)) ) { |
| alt50=1; |
| } |
| switch (alt50) { |
| case 1 : |
| // InternalEssentialOCL.g:5326:2: rule__PatternExpCS__PatternVariableNameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PatternExpCS__PatternVariableNameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPatternExpCSAccess().getPatternVariableNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PatternExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PatternExpCS__Group__1" |
| // InternalEssentialOCL.g:5336:1: rule__PatternExpCS__Group__1 : rule__PatternExpCS__Group__1__Impl rule__PatternExpCS__Group__2 ; |
| public final void rule__PatternExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5340:1: ( rule__PatternExpCS__Group__1__Impl rule__PatternExpCS__Group__2 ) |
| // InternalEssentialOCL.g:5341:2: rule__PatternExpCS__Group__1__Impl rule__PatternExpCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__PatternExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PatternExpCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PatternExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__PatternExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:5348:1: rule__PatternExpCS__Group__1__Impl : ( ':' ) ; |
| public final void rule__PatternExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5352:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:5353:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:5353:1: ( ':' ) |
| // InternalEssentialOCL.g:5354:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPatternExpCSAccess().getColonKeyword_1()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPatternExpCSAccess().getColonKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PatternExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PatternExpCS__Group__2" |
| // InternalEssentialOCL.g:5367:1: rule__PatternExpCS__Group__2 : rule__PatternExpCS__Group__2__Impl ; |
| public final void rule__PatternExpCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5371:1: ( rule__PatternExpCS__Group__2__Impl ) |
| // InternalEssentialOCL.g:5372:2: rule__PatternExpCS__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PatternExpCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PatternExpCS__Group__2" |
| |
| |
| // $ANTLR start "rule__PatternExpCS__Group__2__Impl" |
| // InternalEssentialOCL.g:5378:1: rule__PatternExpCS__Group__2__Impl : ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) ) ; |
| public final void rule__PatternExpCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5382:1: ( ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) ) ) |
| // InternalEssentialOCL.g:5383:1: ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) ) |
| { |
| // InternalEssentialOCL.g:5383:1: ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) ) |
| // InternalEssentialOCL.g:5384:1: ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeAssignment_2()); |
| } |
| // InternalEssentialOCL.g:5385:1: ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) |
| // InternalEssentialOCL.g:5385:2: rule__PatternExpCS__OwnedPatternTypeAssignment_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PatternExpCS__OwnedPatternTypeAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PatternExpCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__LambdaLiteralExpCS__Group__0" |
| // InternalEssentialOCL.g:5401:1: rule__LambdaLiteralExpCS__Group__0 : rule__LambdaLiteralExpCS__Group__0__Impl rule__LambdaLiteralExpCS__Group__1 ; |
| public final void rule__LambdaLiteralExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5405:1: ( rule__LambdaLiteralExpCS__Group__0__Impl rule__LambdaLiteralExpCS__Group__1 ) |
| // InternalEssentialOCL.g:5406:2: rule__LambdaLiteralExpCS__Group__0__Impl rule__LambdaLiteralExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_14); |
| rule__LambdaLiteralExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LambdaLiteralExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LambdaLiteralExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__LambdaLiteralExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:5413:1: rule__LambdaLiteralExpCS__Group__0__Impl : ( 'Lambda' ) ; |
| public final void rule__LambdaLiteralExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5417:1: ( ( 'Lambda' ) ) |
| // InternalEssentialOCL.g:5418:1: ( 'Lambda' ) |
| { |
| // InternalEssentialOCL.g:5418:1: ( 'Lambda' ) |
| // InternalEssentialOCL.g:5419:1: 'Lambda' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLambdaLiteralExpCSAccess().getLambdaKeyword_0()); |
| } |
| match(input,67,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLambdaLiteralExpCSAccess().getLambdaKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LambdaLiteralExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LambdaLiteralExpCS__Group__1" |
| // InternalEssentialOCL.g:5432:1: rule__LambdaLiteralExpCS__Group__1 : rule__LambdaLiteralExpCS__Group__1__Impl rule__LambdaLiteralExpCS__Group__2 ; |
| public final void rule__LambdaLiteralExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5436:1: ( rule__LambdaLiteralExpCS__Group__1__Impl rule__LambdaLiteralExpCS__Group__2 ) |
| // InternalEssentialOCL.g:5437:2: rule__LambdaLiteralExpCS__Group__1__Impl rule__LambdaLiteralExpCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__LambdaLiteralExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LambdaLiteralExpCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LambdaLiteralExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__LambdaLiteralExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:5444:1: rule__LambdaLiteralExpCS__Group__1__Impl : ( '{' ) ; |
| public final void rule__LambdaLiteralExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5448:1: ( ( '{' ) ) |
| // InternalEssentialOCL.g:5449:1: ( '{' ) |
| { |
| // InternalEssentialOCL.g:5449:1: ( '{' ) |
| // InternalEssentialOCL.g:5450:1: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLambdaLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLambdaLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LambdaLiteralExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LambdaLiteralExpCS__Group__2" |
| // InternalEssentialOCL.g:5463:1: rule__LambdaLiteralExpCS__Group__2 : rule__LambdaLiteralExpCS__Group__2__Impl rule__LambdaLiteralExpCS__Group__3 ; |
| public final void rule__LambdaLiteralExpCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5467:1: ( rule__LambdaLiteralExpCS__Group__2__Impl rule__LambdaLiteralExpCS__Group__3 ) |
| // InternalEssentialOCL.g:5468:2: rule__LambdaLiteralExpCS__Group__2__Impl rule__LambdaLiteralExpCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_21); |
| rule__LambdaLiteralExpCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LambdaLiteralExpCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LambdaLiteralExpCS__Group__2" |
| |
| |
| // $ANTLR start "rule__LambdaLiteralExpCS__Group__2__Impl" |
| // InternalEssentialOCL.g:5475:1: rule__LambdaLiteralExpCS__Group__2__Impl : ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) ) ; |
| public final void rule__LambdaLiteralExpCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5479:1: ( ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) ) ) |
| // InternalEssentialOCL.g:5480:1: ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) ) |
| { |
| // InternalEssentialOCL.g:5480:1: ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) ) |
| // InternalEssentialOCL.g:5481:1: ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSAssignment_2()); |
| } |
| // InternalEssentialOCL.g:5482:1: ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) |
| // InternalEssentialOCL.g:5482:2: rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LambdaLiteralExpCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__LambdaLiteralExpCS__Group__3" |
| // InternalEssentialOCL.g:5492:1: rule__LambdaLiteralExpCS__Group__3 : rule__LambdaLiteralExpCS__Group__3__Impl ; |
| public final void rule__LambdaLiteralExpCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5496:1: ( rule__LambdaLiteralExpCS__Group__3__Impl ) |
| // InternalEssentialOCL.g:5497:2: rule__LambdaLiteralExpCS__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LambdaLiteralExpCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LambdaLiteralExpCS__Group__3" |
| |
| |
| // $ANTLR start "rule__LambdaLiteralExpCS__Group__3__Impl" |
| // InternalEssentialOCL.g:5503:1: rule__LambdaLiteralExpCS__Group__3__Impl : ( '}' ) ; |
| public final void rule__LambdaLiteralExpCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5507:1: ( ( '}' ) ) |
| // InternalEssentialOCL.g:5508:1: ( '}' ) |
| { |
| // InternalEssentialOCL.g:5508:1: ( '}' ) |
| // InternalEssentialOCL.g:5509:1: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLambdaLiteralExpCSAccess().getRightCurlyBracketKeyword_3()); |
| } |
| match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLambdaLiteralExpCSAccess().getRightCurlyBracketKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LambdaLiteralExpCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group__0" |
| // InternalEssentialOCL.g:5530:1: rule__MapLiteralExpCS__Group__0 : rule__MapLiteralExpCS__Group__0__Impl rule__MapLiteralExpCS__Group__1 ; |
| public final void rule__MapLiteralExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5534:1: ( rule__MapLiteralExpCS__Group__0__Impl rule__MapLiteralExpCS__Group__1 ) |
| // InternalEssentialOCL.g:5535:2: rule__MapLiteralExpCS__Group__0__Impl rule__MapLiteralExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_14); |
| rule__MapLiteralExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:5542:1: rule__MapLiteralExpCS__Group__0__Impl : ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) ) ; |
| public final void rule__MapLiteralExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5546:1: ( ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:5547:1: ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:5547:1: ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) ) |
| // InternalEssentialOCL.g:5548:1: ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeAssignment_0()); |
| } |
| // InternalEssentialOCL.g:5549:1: ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) |
| // InternalEssentialOCL.g:5549:2: rule__MapLiteralExpCS__OwnedTypeAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__OwnedTypeAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group__1" |
| // InternalEssentialOCL.g:5559:1: rule__MapLiteralExpCS__Group__1 : rule__MapLiteralExpCS__Group__1__Impl rule__MapLiteralExpCS__Group__2 ; |
| public final void rule__MapLiteralExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5563:1: ( rule__MapLiteralExpCS__Group__1__Impl rule__MapLiteralExpCS__Group__2 ) |
| // InternalEssentialOCL.g:5564:2: rule__MapLiteralExpCS__Group__1__Impl rule__MapLiteralExpCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_22); |
| rule__MapLiteralExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:5571:1: rule__MapLiteralExpCS__Group__1__Impl : ( '{' ) ; |
| public final void rule__MapLiteralExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5575:1: ( ( '{' ) ) |
| // InternalEssentialOCL.g:5576:1: ( '{' ) |
| { |
| // InternalEssentialOCL.g:5576:1: ( '{' ) |
| // InternalEssentialOCL.g:5577:1: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group__2" |
| // InternalEssentialOCL.g:5590:1: rule__MapLiteralExpCS__Group__2 : rule__MapLiteralExpCS__Group__2__Impl rule__MapLiteralExpCS__Group__3 ; |
| public final void rule__MapLiteralExpCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5594:1: ( rule__MapLiteralExpCS__Group__2__Impl rule__MapLiteralExpCS__Group__3 ) |
| // InternalEssentialOCL.g:5595:2: rule__MapLiteralExpCS__Group__2__Impl rule__MapLiteralExpCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_22); |
| rule__MapLiteralExpCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group__2" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group__2__Impl" |
| // InternalEssentialOCL.g:5602:1: rule__MapLiteralExpCS__Group__2__Impl : ( ( rule__MapLiteralExpCS__Group_2__0 )? ) ; |
| public final void rule__MapLiteralExpCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5606:1: ( ( ( rule__MapLiteralExpCS__Group_2__0 )? ) ) |
| // InternalEssentialOCL.g:5607:1: ( ( rule__MapLiteralExpCS__Group_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:5607:1: ( ( rule__MapLiteralExpCS__Group_2__0 )? ) |
| // InternalEssentialOCL.g:5608:1: ( rule__MapLiteralExpCS__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getGroup_2()); |
| } |
| // InternalEssentialOCL.g:5609:1: ( rule__MapLiteralExpCS__Group_2__0 )? |
| int alt51=2; |
| int LA51_0 = input.LA(1); |
| |
| if ( ((LA51_0>=RULE_INT && LA51_0<=RULE_ESCAPED_ID)||(LA51_0>=16 && LA51_0<=19)||(LA51_0>=40 && LA51_0<=54)||LA51_0==59||(LA51_0>=67 && LA51_0<=69)||LA51_0==74||(LA51_0>=79 && LA51_0<=80)||(LA51_0>=84 && LA51_0<=85)) ) { |
| alt51=1; |
| } |
| switch (alt51) { |
| case 1 : |
| // InternalEssentialOCL.g:5609:2: rule__MapLiteralExpCS__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group__3" |
| // InternalEssentialOCL.g:5619:1: rule__MapLiteralExpCS__Group__3 : rule__MapLiteralExpCS__Group__3__Impl ; |
| public final void rule__MapLiteralExpCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5623:1: ( rule__MapLiteralExpCS__Group__3__Impl ) |
| // InternalEssentialOCL.g:5624:2: rule__MapLiteralExpCS__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group__3" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group__3__Impl" |
| // InternalEssentialOCL.g:5630:1: rule__MapLiteralExpCS__Group__3__Impl : ( '}' ) ; |
| public final void rule__MapLiteralExpCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5634:1: ( ( '}' ) ) |
| // InternalEssentialOCL.g:5635:1: ( '}' ) |
| { |
| // InternalEssentialOCL.g:5635:1: ( '}' ) |
| // InternalEssentialOCL.g:5636:1: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getRightCurlyBracketKeyword_3()); |
| } |
| match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getRightCurlyBracketKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group_2__0" |
| // InternalEssentialOCL.g:5657:1: rule__MapLiteralExpCS__Group_2__0 : rule__MapLiteralExpCS__Group_2__0__Impl rule__MapLiteralExpCS__Group_2__1 ; |
| public final void rule__MapLiteralExpCS__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5661:1: ( rule__MapLiteralExpCS__Group_2__0__Impl rule__MapLiteralExpCS__Group_2__1 ) |
| // InternalEssentialOCL.g:5662:2: rule__MapLiteralExpCS__Group_2__0__Impl rule__MapLiteralExpCS__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_8); |
| rule__MapLiteralExpCS__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group_2__0" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group_2__0__Impl" |
| // InternalEssentialOCL.g:5669:1: rule__MapLiteralExpCS__Group_2__0__Impl : ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) ) ; |
| public final void rule__MapLiteralExpCS__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5673:1: ( ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) ) ) |
| // InternalEssentialOCL.g:5674:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) ) |
| { |
| // InternalEssentialOCL.g:5674:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) ) |
| // InternalEssentialOCL.g:5675:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_0()); |
| } |
| // InternalEssentialOCL.g:5676:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) |
| // InternalEssentialOCL.g:5676:2: rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__OwnedPartsAssignment_2_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group_2__1" |
| // InternalEssentialOCL.g:5686:1: rule__MapLiteralExpCS__Group_2__1 : rule__MapLiteralExpCS__Group_2__1__Impl ; |
| public final void rule__MapLiteralExpCS__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5690:1: ( rule__MapLiteralExpCS__Group_2__1__Impl ) |
| // InternalEssentialOCL.g:5691:2: rule__MapLiteralExpCS__Group_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__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__MapLiteralExpCS__Group_2__1" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group_2__1__Impl" |
| // InternalEssentialOCL.g:5697:1: rule__MapLiteralExpCS__Group_2__1__Impl : ( ( rule__MapLiteralExpCS__Group_2_1__0 )* ) ; |
| public final void rule__MapLiteralExpCS__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5701:1: ( ( ( rule__MapLiteralExpCS__Group_2_1__0 )* ) ) |
| // InternalEssentialOCL.g:5702:1: ( ( rule__MapLiteralExpCS__Group_2_1__0 )* ) |
| { |
| // InternalEssentialOCL.g:5702:1: ( ( rule__MapLiteralExpCS__Group_2_1__0 )* ) |
| // InternalEssentialOCL.g:5703:1: ( rule__MapLiteralExpCS__Group_2_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getGroup_2_1()); |
| } |
| // InternalEssentialOCL.g:5704:1: ( rule__MapLiteralExpCS__Group_2_1__0 )* |
| loop52: |
| do { |
| int alt52=2; |
| int LA52_0 = input.LA(1); |
| |
| if ( (LA52_0==61) ) { |
| alt52=1; |
| } |
| |
| |
| switch (alt52) { |
| case 1 : |
| // InternalEssentialOCL.g:5704:2: rule__MapLiteralExpCS__Group_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_11); |
| rule__MapLiteralExpCS__Group_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop52; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getGroup_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__0" |
| // InternalEssentialOCL.g:5718:1: rule__MapLiteralExpCS__Group_2_1__0 : rule__MapLiteralExpCS__Group_2_1__0__Impl rule__MapLiteralExpCS__Group_2_1__1 ; |
| public final void rule__MapLiteralExpCS__Group_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5722:1: ( rule__MapLiteralExpCS__Group_2_1__0__Impl rule__MapLiteralExpCS__Group_2_1__1 ) |
| // InternalEssentialOCL.g:5723:2: rule__MapLiteralExpCS__Group_2_1__0__Impl rule__MapLiteralExpCS__Group_2_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__MapLiteralExpCS__Group_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__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__MapLiteralExpCS__Group_2_1__0" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__0__Impl" |
| // InternalEssentialOCL.g:5730:1: rule__MapLiteralExpCS__Group_2_1__0__Impl : ( ',' ) ; |
| public final void rule__MapLiteralExpCS__Group_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5734:1: ( ( ',' ) ) |
| // InternalEssentialOCL.g:5735:1: ( ',' ) |
| { |
| // InternalEssentialOCL.g:5735:1: ( ',' ) |
| // InternalEssentialOCL.g:5736:1: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getCommaKeyword_2_1_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getCommaKeyword_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__1" |
| // InternalEssentialOCL.g:5749:1: rule__MapLiteralExpCS__Group_2_1__1 : rule__MapLiteralExpCS__Group_2_1__1__Impl ; |
| public final void rule__MapLiteralExpCS__Group_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5753:1: ( rule__MapLiteralExpCS__Group_2_1__1__Impl ) |
| // InternalEssentialOCL.g:5754:2: rule__MapLiteralExpCS__Group_2_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__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__MapLiteralExpCS__Group_2_1__1" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__1__Impl" |
| // InternalEssentialOCL.g:5760:1: rule__MapLiteralExpCS__Group_2_1__1__Impl : ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) ; |
| public final void rule__MapLiteralExpCS__Group_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5764:1: ( ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) ) |
| // InternalEssentialOCL.g:5765:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:5765:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) |
| // InternalEssentialOCL.g:5766:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1()); |
| } |
| // InternalEssentialOCL.g:5767:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) |
| // InternalEssentialOCL.g:5767:2: rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__Group_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__MapLiteralPartCS__Group__0" |
| // InternalEssentialOCL.g:5781:1: rule__MapLiteralPartCS__Group__0 : rule__MapLiteralPartCS__Group__0__Impl rule__MapLiteralPartCS__Group__1 ; |
| public final void rule__MapLiteralPartCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5785:1: ( rule__MapLiteralPartCS__Group__0__Impl rule__MapLiteralPartCS__Group__1 ) |
| // InternalEssentialOCL.g:5786:2: rule__MapLiteralPartCS__Group__0__Impl rule__MapLiteralPartCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_23); |
| rule__MapLiteralPartCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralPartCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralPartCS__Group__0" |
| |
| |
| // $ANTLR start "rule__MapLiteralPartCS__Group__0__Impl" |
| // InternalEssentialOCL.g:5793:1: rule__MapLiteralPartCS__Group__0__Impl : ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) ) ; |
| public final void rule__MapLiteralPartCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5797:1: ( ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:5798:1: ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:5798:1: ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) ) |
| // InternalEssentialOCL.g:5799:1: ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyAssignment_0()); |
| } |
| // InternalEssentialOCL.g:5800:1: ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) |
| // InternalEssentialOCL.g:5800:2: rule__MapLiteralPartCS__OwnedKeyAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralPartCS__OwnedKeyAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralPartCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__MapLiteralPartCS__Group__1" |
| // InternalEssentialOCL.g:5810:1: rule__MapLiteralPartCS__Group__1 : rule__MapLiteralPartCS__Group__1__Impl rule__MapLiteralPartCS__Group__2 ; |
| public final void rule__MapLiteralPartCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5814:1: ( rule__MapLiteralPartCS__Group__1__Impl rule__MapLiteralPartCS__Group__2 ) |
| // InternalEssentialOCL.g:5815:2: rule__MapLiteralPartCS__Group__1__Impl rule__MapLiteralPartCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__MapLiteralPartCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralPartCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralPartCS__Group__1" |
| |
| |
| // $ANTLR start "rule__MapLiteralPartCS__Group__1__Impl" |
| // InternalEssentialOCL.g:5822:1: rule__MapLiteralPartCS__Group__1__Impl : ( ( rule__MapLiteralPartCS__Alternatives_1 ) ) ; |
| public final void rule__MapLiteralPartCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5826:1: ( ( ( rule__MapLiteralPartCS__Alternatives_1 ) ) ) |
| // InternalEssentialOCL.g:5827:1: ( ( rule__MapLiteralPartCS__Alternatives_1 ) ) |
| { |
| // InternalEssentialOCL.g:5827:1: ( ( rule__MapLiteralPartCS__Alternatives_1 ) ) |
| // InternalEssentialOCL.g:5828:1: ( rule__MapLiteralPartCS__Alternatives_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralPartCSAccess().getAlternatives_1()); |
| } |
| // InternalEssentialOCL.g:5829:1: ( rule__MapLiteralPartCS__Alternatives_1 ) |
| // InternalEssentialOCL.g:5829:2: rule__MapLiteralPartCS__Alternatives_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralPartCS__Alternatives_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralPartCSAccess().getAlternatives_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralPartCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__MapLiteralPartCS__Group__2" |
| // InternalEssentialOCL.g:5839:1: rule__MapLiteralPartCS__Group__2 : rule__MapLiteralPartCS__Group__2__Impl ; |
| public final void rule__MapLiteralPartCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5843:1: ( rule__MapLiteralPartCS__Group__2__Impl ) |
| // InternalEssentialOCL.g:5844:2: rule__MapLiteralPartCS__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralPartCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralPartCS__Group__2" |
| |
| |
| // $ANTLR start "rule__MapLiteralPartCS__Group__2__Impl" |
| // InternalEssentialOCL.g:5850:1: rule__MapLiteralPartCS__Group__2__Impl : ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) ) ; |
| public final void rule__MapLiteralPartCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5854:1: ( ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) ) ) |
| // InternalEssentialOCL.g:5855:1: ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) ) |
| { |
| // InternalEssentialOCL.g:5855:1: ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) ) |
| // InternalEssentialOCL.g:5856:1: ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueAssignment_2()); |
| } |
| // InternalEssentialOCL.g:5857:1: ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) |
| // InternalEssentialOCL.g:5857:2: rule__MapLiteralPartCS__OwnedValueAssignment_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MapLiteralPartCS__OwnedValueAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralPartCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group__0" |
| // InternalEssentialOCL.g:5873:1: rule__TupleLiteralExpCS__Group__0 : rule__TupleLiteralExpCS__Group__0__Impl rule__TupleLiteralExpCS__Group__1 ; |
| public final void rule__TupleLiteralExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5877:1: ( rule__TupleLiteralExpCS__Group__0__Impl rule__TupleLiteralExpCS__Group__1 ) |
| // InternalEssentialOCL.g:5878:2: rule__TupleLiteralExpCS__Group__0__Impl rule__TupleLiteralExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_14); |
| rule__TupleLiteralExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:5885:1: rule__TupleLiteralExpCS__Group__0__Impl : ( 'Tuple' ) ; |
| public final void rule__TupleLiteralExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5889:1: ( ( 'Tuple' ) ) |
| // InternalEssentialOCL.g:5890:1: ( 'Tuple' ) |
| { |
| // InternalEssentialOCL.g:5890:1: ( 'Tuple' ) |
| // InternalEssentialOCL.g:5891:1: 'Tuple' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralExpCSAccess().getTupleKeyword_0()); |
| } |
| match(input,41,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralExpCSAccess().getTupleKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group__1" |
| // InternalEssentialOCL.g:5904:1: rule__TupleLiteralExpCS__Group__1 : rule__TupleLiteralExpCS__Group__1__Impl rule__TupleLiteralExpCS__Group__2 ; |
| public final void rule__TupleLiteralExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5908:1: ( rule__TupleLiteralExpCS__Group__1__Impl rule__TupleLiteralExpCS__Group__2 ) |
| // InternalEssentialOCL.g:5909:2: rule__TupleLiteralExpCS__Group__1__Impl rule__TupleLiteralExpCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__TupleLiteralExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralExpCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:5916:1: rule__TupleLiteralExpCS__Group__1__Impl : ( '{' ) ; |
| public final void rule__TupleLiteralExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5920:1: ( ( '{' ) ) |
| // InternalEssentialOCL.g:5921:1: ( '{' ) |
| { |
| // InternalEssentialOCL.g:5921:1: ( '{' ) |
| // InternalEssentialOCL.g:5922:1: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group__2" |
| // InternalEssentialOCL.g:5935:1: rule__TupleLiteralExpCS__Group__2 : rule__TupleLiteralExpCS__Group__2__Impl rule__TupleLiteralExpCS__Group__3 ; |
| public final void rule__TupleLiteralExpCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5939:1: ( rule__TupleLiteralExpCS__Group__2__Impl rule__TupleLiteralExpCS__Group__3 ) |
| // InternalEssentialOCL.g:5940:2: rule__TupleLiteralExpCS__Group__2__Impl rule__TupleLiteralExpCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_24); |
| rule__TupleLiteralExpCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralExpCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group__2" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group__2__Impl" |
| // InternalEssentialOCL.g:5947:1: rule__TupleLiteralExpCS__Group__2__Impl : ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) ) ; |
| public final void rule__TupleLiteralExpCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5951:1: ( ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) ) ) |
| // InternalEssentialOCL.g:5952:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) ) |
| { |
| // InternalEssentialOCL.g:5952:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) ) |
| // InternalEssentialOCL.g:5953:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_2()); |
| } |
| // InternalEssentialOCL.g:5954:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) |
| // InternalEssentialOCL.g:5954:2: rule__TupleLiteralExpCS__OwnedPartsAssignment_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralExpCS__OwnedPartsAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group__3" |
| // InternalEssentialOCL.g:5964:1: rule__TupleLiteralExpCS__Group__3 : rule__TupleLiteralExpCS__Group__3__Impl rule__TupleLiteralExpCS__Group__4 ; |
| public final void rule__TupleLiteralExpCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5968:1: ( rule__TupleLiteralExpCS__Group__3__Impl rule__TupleLiteralExpCS__Group__4 ) |
| // InternalEssentialOCL.g:5969:2: rule__TupleLiteralExpCS__Group__3__Impl rule__TupleLiteralExpCS__Group__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_24); |
| rule__TupleLiteralExpCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralExpCS__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group__3" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group__3__Impl" |
| // InternalEssentialOCL.g:5976:1: rule__TupleLiteralExpCS__Group__3__Impl : ( ( rule__TupleLiteralExpCS__Group_3__0 )* ) ; |
| public final void rule__TupleLiteralExpCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5980:1: ( ( ( rule__TupleLiteralExpCS__Group_3__0 )* ) ) |
| // InternalEssentialOCL.g:5981:1: ( ( rule__TupleLiteralExpCS__Group_3__0 )* ) |
| { |
| // InternalEssentialOCL.g:5981:1: ( ( rule__TupleLiteralExpCS__Group_3__0 )* ) |
| // InternalEssentialOCL.g:5982:1: ( rule__TupleLiteralExpCS__Group_3__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralExpCSAccess().getGroup_3()); |
| } |
| // InternalEssentialOCL.g:5983:1: ( rule__TupleLiteralExpCS__Group_3__0 )* |
| loop53: |
| do { |
| int alt53=2; |
| int LA53_0 = input.LA(1); |
| |
| if ( (LA53_0==61) ) { |
| alt53=1; |
| } |
| |
| |
| switch (alt53) { |
| case 1 : |
| // InternalEssentialOCL.g:5983:2: rule__TupleLiteralExpCS__Group_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_11); |
| rule__TupleLiteralExpCS__Group_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop53; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralExpCSAccess().getGroup_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group__4" |
| // InternalEssentialOCL.g:5993:1: rule__TupleLiteralExpCS__Group__4 : rule__TupleLiteralExpCS__Group__4__Impl ; |
| public final void rule__TupleLiteralExpCS__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:5997:1: ( rule__TupleLiteralExpCS__Group__4__Impl ) |
| // InternalEssentialOCL.g:5998:2: rule__TupleLiteralExpCS__Group__4__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralExpCS__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group__4" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group__4__Impl" |
| // InternalEssentialOCL.g:6004:1: rule__TupleLiteralExpCS__Group__4__Impl : ( '}' ) ; |
| public final void rule__TupleLiteralExpCS__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6008:1: ( ( '}' ) ) |
| // InternalEssentialOCL.g:6009:1: ( '}' ) |
| { |
| // InternalEssentialOCL.g:6009:1: ( '}' ) |
| // InternalEssentialOCL.g:6010:1: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralExpCSAccess().getRightCurlyBracketKeyword_4()); |
| } |
| match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralExpCSAccess().getRightCurlyBracketKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group_3__0" |
| // InternalEssentialOCL.g:6033:1: rule__TupleLiteralExpCS__Group_3__0 : rule__TupleLiteralExpCS__Group_3__0__Impl rule__TupleLiteralExpCS__Group_3__1 ; |
| public final void rule__TupleLiteralExpCS__Group_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6037:1: ( rule__TupleLiteralExpCS__Group_3__0__Impl rule__TupleLiteralExpCS__Group_3__1 ) |
| // InternalEssentialOCL.g:6038:2: rule__TupleLiteralExpCS__Group_3__0__Impl rule__TupleLiteralExpCS__Group_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__TupleLiteralExpCS__Group_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralExpCS__Group_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group_3__0" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group_3__0__Impl" |
| // InternalEssentialOCL.g:6045:1: rule__TupleLiteralExpCS__Group_3__0__Impl : ( ',' ) ; |
| public final void rule__TupleLiteralExpCS__Group_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6049:1: ( ( ',' ) ) |
| // InternalEssentialOCL.g:6050:1: ( ',' ) |
| { |
| // InternalEssentialOCL.g:6050:1: ( ',' ) |
| // InternalEssentialOCL.g:6051:1: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralExpCSAccess().getCommaKeyword_3_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralExpCSAccess().getCommaKeyword_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group_3__1" |
| // InternalEssentialOCL.g:6064:1: rule__TupleLiteralExpCS__Group_3__1 : rule__TupleLiteralExpCS__Group_3__1__Impl ; |
| public final void rule__TupleLiteralExpCS__Group_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6068:1: ( rule__TupleLiteralExpCS__Group_3__1__Impl ) |
| // InternalEssentialOCL.g:6069:2: rule__TupleLiteralExpCS__Group_3__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralExpCS__Group_3__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group_3__1" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__Group_3__1__Impl" |
| // InternalEssentialOCL.g:6075:1: rule__TupleLiteralExpCS__Group_3__1__Impl : ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) ) ; |
| public final void rule__TupleLiteralExpCS__Group_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6079:1: ( ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) ) ) |
| // InternalEssentialOCL.g:6080:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) ) |
| { |
| // InternalEssentialOCL.g:6080:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) ) |
| // InternalEssentialOCL.g:6081:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_3_1()); |
| } |
| // InternalEssentialOCL.g:6082:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) |
| // InternalEssentialOCL.g:6082:2: rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__Group_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group__0" |
| // InternalEssentialOCL.g:6096:1: rule__TupleLiteralPartCS__Group__0 : rule__TupleLiteralPartCS__Group__0__Impl rule__TupleLiteralPartCS__Group__1 ; |
| public final void rule__TupleLiteralPartCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6100:1: ( rule__TupleLiteralPartCS__Group__0__Impl rule__TupleLiteralPartCS__Group__1 ) |
| // InternalEssentialOCL.g:6101:2: rule__TupleLiteralPartCS__Group__0__Impl rule__TupleLiteralPartCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__TupleLiteralPartCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralPartCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__Group__0" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group__0__Impl" |
| // InternalEssentialOCL.g:6108:1: rule__TupleLiteralPartCS__Group__0__Impl : ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) ) ; |
| public final void rule__TupleLiteralPartCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6112:1: ( ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:6113:1: ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:6113:1: ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) ) |
| // InternalEssentialOCL.g:6114:1: ( rule__TupleLiteralPartCS__NameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralPartCSAccess().getNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:6115:1: ( rule__TupleLiteralPartCS__NameAssignment_0 ) |
| // InternalEssentialOCL.g:6115:2: rule__TupleLiteralPartCS__NameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralPartCS__NameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralPartCSAccess().getNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group__1" |
| // InternalEssentialOCL.g:6125:1: rule__TupleLiteralPartCS__Group__1 : rule__TupleLiteralPartCS__Group__1__Impl rule__TupleLiteralPartCS__Group__2 ; |
| public final void rule__TupleLiteralPartCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6129:1: ( rule__TupleLiteralPartCS__Group__1__Impl rule__TupleLiteralPartCS__Group__2 ) |
| // InternalEssentialOCL.g:6130:2: rule__TupleLiteralPartCS__Group__1__Impl rule__TupleLiteralPartCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_25); |
| rule__TupleLiteralPartCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralPartCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__Group__1" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group__1__Impl" |
| // InternalEssentialOCL.g:6137:1: rule__TupleLiteralPartCS__Group__1__Impl : ( ( rule__TupleLiteralPartCS__Group_1__0 )? ) ; |
| public final void rule__TupleLiteralPartCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6141:1: ( ( ( rule__TupleLiteralPartCS__Group_1__0 )? ) ) |
| // InternalEssentialOCL.g:6142:1: ( ( rule__TupleLiteralPartCS__Group_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:6142:1: ( ( rule__TupleLiteralPartCS__Group_1__0 )? ) |
| // InternalEssentialOCL.g:6143:1: ( rule__TupleLiteralPartCS__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralPartCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:6144:1: ( rule__TupleLiteralPartCS__Group_1__0 )? |
| int alt54=2; |
| int LA54_0 = input.LA(1); |
| |
| if ( (LA54_0==62) ) { |
| alt54=1; |
| } |
| switch (alt54) { |
| case 1 : |
| // InternalEssentialOCL.g:6144:2: rule__TupleLiteralPartCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralPartCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralPartCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group__2" |
| // InternalEssentialOCL.g:6154:1: rule__TupleLiteralPartCS__Group__2 : rule__TupleLiteralPartCS__Group__2__Impl rule__TupleLiteralPartCS__Group__3 ; |
| public final void rule__TupleLiteralPartCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6158:1: ( rule__TupleLiteralPartCS__Group__2__Impl rule__TupleLiteralPartCS__Group__3 ) |
| // InternalEssentialOCL.g:6159:2: rule__TupleLiteralPartCS__Group__2__Impl rule__TupleLiteralPartCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__TupleLiteralPartCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralPartCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__Group__2" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group__2__Impl" |
| // InternalEssentialOCL.g:6166:1: rule__TupleLiteralPartCS__Group__2__Impl : ( '=' ) ; |
| public final void rule__TupleLiteralPartCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6170:1: ( ( '=' ) ) |
| // InternalEssentialOCL.g:6171:1: ( '=' ) |
| { |
| // InternalEssentialOCL.g:6171:1: ( '=' ) |
| // InternalEssentialOCL.g:6172:1: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralPartCSAccess().getEqualsSignKeyword_2()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralPartCSAccess().getEqualsSignKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group__3" |
| // InternalEssentialOCL.g:6185:1: rule__TupleLiteralPartCS__Group__3 : rule__TupleLiteralPartCS__Group__3__Impl ; |
| public final void rule__TupleLiteralPartCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6189:1: ( rule__TupleLiteralPartCS__Group__3__Impl ) |
| // InternalEssentialOCL.g:6190:2: rule__TupleLiteralPartCS__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralPartCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__Group__3" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group__3__Impl" |
| // InternalEssentialOCL.g:6196:1: rule__TupleLiteralPartCS__Group__3__Impl : ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) ) ; |
| public final void rule__TupleLiteralPartCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6200:1: ( ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) ) ) |
| // InternalEssentialOCL.g:6201:1: ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) ) |
| { |
| // InternalEssentialOCL.g:6201:1: ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) ) |
| // InternalEssentialOCL.g:6202:1: ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionAssignment_3()); |
| } |
| // InternalEssentialOCL.g:6203:1: ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) |
| // InternalEssentialOCL.g:6203:2: rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group_1__0" |
| // InternalEssentialOCL.g:6221:1: rule__TupleLiteralPartCS__Group_1__0 : rule__TupleLiteralPartCS__Group_1__0__Impl rule__TupleLiteralPartCS__Group_1__1 ; |
| public final void rule__TupleLiteralPartCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6225:1: ( rule__TupleLiteralPartCS__Group_1__0__Impl rule__TupleLiteralPartCS__Group_1__1 ) |
| // InternalEssentialOCL.g:6226:2: rule__TupleLiteralPartCS__Group_1__0__Impl rule__TupleLiteralPartCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__TupleLiteralPartCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralPartCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:6233:1: rule__TupleLiteralPartCS__Group_1__0__Impl : ( ':' ) ; |
| public final void rule__TupleLiteralPartCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6237:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:6238:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:6238:1: ( ':' ) |
| // InternalEssentialOCL.g:6239:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralPartCSAccess().getColonKeyword_1_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralPartCSAccess().getColonKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group_1__1" |
| // InternalEssentialOCL.g:6252:1: rule__TupleLiteralPartCS__Group_1__1 : rule__TupleLiteralPartCS__Group_1__1__Impl ; |
| public final void rule__TupleLiteralPartCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6256:1: ( rule__TupleLiteralPartCS__Group_1__1__Impl ) |
| // InternalEssentialOCL.g:6257:2: rule__TupleLiteralPartCS__Group_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralPartCS__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__TupleLiteralPartCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:6263:1: rule__TupleLiteralPartCS__Group_1__1__Impl : ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) ) ; |
| public final void rule__TupleLiteralPartCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6267:1: ( ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) ) ) |
| // InternalEssentialOCL.g:6268:1: ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:6268:1: ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) ) |
| // InternalEssentialOCL.g:6269:1: ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeAssignment_1_1()); |
| } |
| // InternalEssentialOCL.g:6270:1: ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) |
| // InternalEssentialOCL.g:6270:2: rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__0" |
| // InternalEssentialOCL.g:6284:1: rule__UnlimitedNaturalLiteralExpCS__Group__0 : rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl rule__UnlimitedNaturalLiteralExpCS__Group__1 ; |
| public final void rule__UnlimitedNaturalLiteralExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6288:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl rule__UnlimitedNaturalLiteralExpCS__Group__1 ) |
| // InternalEssentialOCL.g:6289:2: rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl rule__UnlimitedNaturalLiteralExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_26); |
| rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__UnlimitedNaturalLiteralExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:6296:1: rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl : ( () ) ; |
| public final void rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6300:1: ( ( () ) ) |
| // InternalEssentialOCL.g:6301:1: ( () ) |
| { |
| // InternalEssentialOCL.g:6301:1: ( () ) |
| // InternalEssentialOCL.g:6302:1: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSAction_0()); |
| } |
| // InternalEssentialOCL.g:6303:1: () |
| // InternalEssentialOCL.g:6305:1: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__1" |
| // InternalEssentialOCL.g:6315:1: rule__UnlimitedNaturalLiteralExpCS__Group__1 : rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl ; |
| public final void rule__UnlimitedNaturalLiteralExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6319:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:6320:2: rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:6326:1: rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl : ( '*' ) ; |
| public final void rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6330:1: ( ( '*' ) ) |
| // InternalEssentialOCL.g:6331:1: ( '*' ) |
| { |
| // InternalEssentialOCL.g:6331:1: ( '*' ) |
| // InternalEssentialOCL.g:6332:1: '*' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getAsteriskKeyword_1()); |
| } |
| match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getAsteriskKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__InvalidLiteralExpCS__Group__0" |
| // InternalEssentialOCL.g:6349:1: rule__InvalidLiteralExpCS__Group__0 : rule__InvalidLiteralExpCS__Group__0__Impl rule__InvalidLiteralExpCS__Group__1 ; |
| public final void rule__InvalidLiteralExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6353:1: ( rule__InvalidLiteralExpCS__Group__0__Impl rule__InvalidLiteralExpCS__Group__1 ) |
| // InternalEssentialOCL.g:6354:2: rule__InvalidLiteralExpCS__Group__0__Impl rule__InvalidLiteralExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_27); |
| rule__InvalidLiteralExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__InvalidLiteralExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InvalidLiteralExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__InvalidLiteralExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:6361:1: rule__InvalidLiteralExpCS__Group__0__Impl : ( () ) ; |
| public final void rule__InvalidLiteralExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6365:1: ( ( () ) ) |
| // InternalEssentialOCL.g:6366:1: ( () ) |
| { |
| // InternalEssentialOCL.g:6366:1: ( () ) |
| // InternalEssentialOCL.g:6367:1: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidLiteralExpCSAction_0()); |
| } |
| // InternalEssentialOCL.g:6368:1: () |
| // InternalEssentialOCL.g:6370:1: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidLiteralExpCSAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InvalidLiteralExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__InvalidLiteralExpCS__Group__1" |
| // InternalEssentialOCL.g:6380:1: rule__InvalidLiteralExpCS__Group__1 : rule__InvalidLiteralExpCS__Group__1__Impl ; |
| public final void rule__InvalidLiteralExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6384:1: ( rule__InvalidLiteralExpCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:6385:2: rule__InvalidLiteralExpCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__InvalidLiteralExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InvalidLiteralExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__InvalidLiteralExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:6391:1: rule__InvalidLiteralExpCS__Group__1__Impl : ( 'invalid' ) ; |
| public final void rule__InvalidLiteralExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6395:1: ( ( 'invalid' ) ) |
| // InternalEssentialOCL.g:6396:1: ( 'invalid' ) |
| { |
| // InternalEssentialOCL.g:6396:1: ( 'invalid' ) |
| // InternalEssentialOCL.g:6397:1: 'invalid' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidKeyword_1()); |
| } |
| match(input,68,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InvalidLiteralExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__NullLiteralExpCS__Group__0" |
| // InternalEssentialOCL.g:6414:1: rule__NullLiteralExpCS__Group__0 : rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1 ; |
| public final void rule__NullLiteralExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6418:1: ( rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1 ) |
| // InternalEssentialOCL.g:6419:2: rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_28); |
| rule__NullLiteralExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NullLiteralExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NullLiteralExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__NullLiteralExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:6426:1: rule__NullLiteralExpCS__Group__0__Impl : ( () ) ; |
| public final void rule__NullLiteralExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6430:1: ( ( () ) ) |
| // InternalEssentialOCL.g:6431:1: ( () ) |
| { |
| // InternalEssentialOCL.g:6431:1: ( () ) |
| // InternalEssentialOCL.g:6432:1: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNullLiteralExpCSAccess().getNullLiteralExpCSAction_0()); |
| } |
| // InternalEssentialOCL.g:6433:1: () |
| // InternalEssentialOCL.g:6435:1: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNullLiteralExpCSAccess().getNullLiteralExpCSAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NullLiteralExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__NullLiteralExpCS__Group__1" |
| // InternalEssentialOCL.g:6445:1: rule__NullLiteralExpCS__Group__1 : rule__NullLiteralExpCS__Group__1__Impl ; |
| public final void rule__NullLiteralExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6449:1: ( rule__NullLiteralExpCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:6450:2: rule__NullLiteralExpCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NullLiteralExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NullLiteralExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__NullLiteralExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:6456:1: rule__NullLiteralExpCS__Group__1__Impl : ( 'null' ) ; |
| public final void rule__NullLiteralExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6460:1: ( ( 'null' ) ) |
| // InternalEssentialOCL.g:6461:1: ( 'null' ) |
| { |
| // InternalEssentialOCL.g:6461:1: ( 'null' ) |
| // InternalEssentialOCL.g:6462:1: 'null' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNullLiteralExpCSAccess().getNullKeyword_1()); |
| } |
| match(input,69,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNullLiteralExpCSAccess().getNullKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NullLiteralExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__0" |
| // InternalEssentialOCL.g:6479:1: rule__TypeLiteralWithMultiplicityCS__Group__0 : rule__TypeLiteralWithMultiplicityCS__Group__0__Impl rule__TypeLiteralWithMultiplicityCS__Group__1 ; |
| public final void rule__TypeLiteralWithMultiplicityCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6483:1: ( rule__TypeLiteralWithMultiplicityCS__Group__0__Impl rule__TypeLiteralWithMultiplicityCS__Group__1 ) |
| // InternalEssentialOCL.g:6484:2: rule__TypeLiteralWithMultiplicityCS__Group__0__Impl rule__TypeLiteralWithMultiplicityCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_29); |
| rule__TypeLiteralWithMultiplicityCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeLiteralWithMultiplicityCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__0" |
| |
| |
| // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__0__Impl" |
| // InternalEssentialOCL.g:6491:1: rule__TypeLiteralWithMultiplicityCS__Group__0__Impl : ( ruleTypeLiteralCS ) ; |
| public final void rule__TypeLiteralWithMultiplicityCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6495:1: ( ( ruleTypeLiteralCS ) ) |
| // InternalEssentialOCL.g:6496:1: ( ruleTypeLiteralCS ) |
| { |
| // InternalEssentialOCL.g:6496:1: ( ruleTypeLiteralCS ) |
| // InternalEssentialOCL.g:6497:1: ruleTypeLiteralCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeLiteralCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__1" |
| // InternalEssentialOCL.g:6508:1: rule__TypeLiteralWithMultiplicityCS__Group__1 : rule__TypeLiteralWithMultiplicityCS__Group__1__Impl ; |
| public final void rule__TypeLiteralWithMultiplicityCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6512:1: ( rule__TypeLiteralWithMultiplicityCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:6513:2: rule__TypeLiteralWithMultiplicityCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeLiteralWithMultiplicityCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__1" |
| |
| |
| // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__1__Impl" |
| // InternalEssentialOCL.g:6519:1: rule__TypeLiteralWithMultiplicityCS__Group__1__Impl : ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? ) ; |
| public final void rule__TypeLiteralWithMultiplicityCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6523:1: ( ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? ) ) |
| // InternalEssentialOCL.g:6524:1: ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? ) |
| { |
| // InternalEssentialOCL.g:6524:1: ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? ) |
| // InternalEssentialOCL.g:6525:1: ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityAssignment_1()); |
| } |
| // InternalEssentialOCL.g:6526:1: ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? |
| int alt55=2; |
| int LA55_0 = input.LA(1); |
| |
| if ( (LA55_0==71) ) { |
| alt55=1; |
| } |
| switch (alt55) { |
| case 1 : |
| // InternalEssentialOCL.g:6526:2: rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group__0" |
| // InternalEssentialOCL.g:6540:1: rule__TypeNameExpCS__Group__0 : rule__TypeNameExpCS__Group__0__Impl rule__TypeNameExpCS__Group__1 ; |
| public final void rule__TypeNameExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6544:1: ( rule__TypeNameExpCS__Group__0__Impl rule__TypeNameExpCS__Group__1 ) |
| // InternalEssentialOCL.g:6545:2: rule__TypeNameExpCS__Group__0__Impl rule__TypeNameExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_14); |
| rule__TypeNameExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:6552:1: rule__TypeNameExpCS__Group__0__Impl : ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) ) ; |
| public final void rule__TypeNameExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6556:1: ( ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:6557:1: ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:6557:1: ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) ) |
| // InternalEssentialOCL.g:6558:1: ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:6559:1: ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) |
| // InternalEssentialOCL.g:6559:2: rule__TypeNameExpCS__OwnedPathNameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__OwnedPathNameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group__1" |
| // InternalEssentialOCL.g:6569:1: rule__TypeNameExpCS__Group__1 : rule__TypeNameExpCS__Group__1__Impl ; |
| public final void rule__TypeNameExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6573:1: ( rule__TypeNameExpCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:6574:2: rule__TypeNameExpCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:6580:1: rule__TypeNameExpCS__Group__1__Impl : ( ( rule__TypeNameExpCS__Group_1__0 )? ) ; |
| public final void rule__TypeNameExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6584:1: ( ( ( rule__TypeNameExpCS__Group_1__0 )? ) ) |
| // InternalEssentialOCL.g:6585:1: ( ( rule__TypeNameExpCS__Group_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:6585:1: ( ( rule__TypeNameExpCS__Group_1__0 )? ) |
| // InternalEssentialOCL.g:6586:1: ( rule__TypeNameExpCS__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:6587:1: ( rule__TypeNameExpCS__Group_1__0 )? |
| int alt56=2; |
| int LA56_0 = input.LA(1); |
| |
| if ( (LA56_0==63) ) { |
| alt56=1; |
| } |
| switch (alt56) { |
| case 1 : |
| // InternalEssentialOCL.g:6587:2: rule__TypeNameExpCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group_1__0" |
| // InternalEssentialOCL.g:6601:1: rule__TypeNameExpCS__Group_1__0 : rule__TypeNameExpCS__Group_1__0__Impl rule__TypeNameExpCS__Group_1__1 ; |
| public final void rule__TypeNameExpCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6605:1: ( rule__TypeNameExpCS__Group_1__0__Impl rule__TypeNameExpCS__Group_1__1 ) |
| // InternalEssentialOCL.g:6606:2: rule__TypeNameExpCS__Group_1__0__Impl rule__TypeNameExpCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_14); |
| rule__TypeNameExpCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:6613:1: rule__TypeNameExpCS__Group_1__0__Impl : ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) ) ; |
| public final void rule__TypeNameExpCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6617:1: ( ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) ) ) |
| // InternalEssentialOCL.g:6618:1: ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) ) |
| { |
| // InternalEssentialOCL.g:6618:1: ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) ) |
| // InternalEssentialOCL.g:6619:1: ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_1_0()); |
| } |
| // InternalEssentialOCL.g:6620:1: ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) |
| // InternalEssentialOCL.g:6620:2: rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group_1__1" |
| // InternalEssentialOCL.g:6630:1: rule__TypeNameExpCS__Group_1__1 : rule__TypeNameExpCS__Group_1__1__Impl ; |
| public final void rule__TypeNameExpCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6634:1: ( rule__TypeNameExpCS__Group_1__1__Impl ) |
| // InternalEssentialOCL.g:6635:2: rule__TypeNameExpCS__Group_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__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__TypeNameExpCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:6641:1: rule__TypeNameExpCS__Group_1__1__Impl : ( ( rule__TypeNameExpCS__Group_1_1__0 )? ) ; |
| public final void rule__TypeNameExpCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6645:1: ( ( ( rule__TypeNameExpCS__Group_1_1__0 )? ) ) |
| // InternalEssentialOCL.g:6646:1: ( ( rule__TypeNameExpCS__Group_1_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:6646:1: ( ( rule__TypeNameExpCS__Group_1_1__0 )? ) |
| // InternalEssentialOCL.g:6647:1: ( rule__TypeNameExpCS__Group_1_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSAccess().getGroup_1_1()); |
| } |
| // InternalEssentialOCL.g:6648:1: ( rule__TypeNameExpCS__Group_1_1__0 )? |
| int alt57=2; |
| int LA57_0 = input.LA(1); |
| |
| if ( (LA57_0==63) ) { |
| alt57=1; |
| } |
| switch (alt57) { |
| case 1 : |
| // InternalEssentialOCL.g:6648:2: rule__TypeNameExpCS__Group_1_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__Group_1_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSAccess().getGroup_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group_1_1__0" |
| // InternalEssentialOCL.g:6662:1: rule__TypeNameExpCS__Group_1_1__0 : rule__TypeNameExpCS__Group_1_1__0__Impl rule__TypeNameExpCS__Group_1_1__1 ; |
| public final void rule__TypeNameExpCS__Group_1_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6666:1: ( rule__TypeNameExpCS__Group_1_1__0__Impl rule__TypeNameExpCS__Group_1_1__1 ) |
| // InternalEssentialOCL.g:6667:2: rule__TypeNameExpCS__Group_1_1__0__Impl rule__TypeNameExpCS__Group_1_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__TypeNameExpCS__Group_1_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__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__TypeNameExpCS__Group_1_1__0" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group_1_1__0__Impl" |
| // InternalEssentialOCL.g:6674:1: rule__TypeNameExpCS__Group_1_1__0__Impl : ( '{' ) ; |
| public final void rule__TypeNameExpCS__Group_1_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6678:1: ( ( '{' ) ) |
| // InternalEssentialOCL.g:6679:1: ( '{' ) |
| { |
| // InternalEssentialOCL.g:6679:1: ( '{' ) |
| // InternalEssentialOCL.g:6680:1: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSAccess().getLeftCurlyBracketKeyword_1_1_0()); |
| } |
| match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSAccess().getLeftCurlyBracketKeyword_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__Group_1_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group_1_1__1" |
| // InternalEssentialOCL.g:6693:1: rule__TypeNameExpCS__Group_1_1__1 : rule__TypeNameExpCS__Group_1_1__1__Impl rule__TypeNameExpCS__Group_1_1__2 ; |
| public final void rule__TypeNameExpCS__Group_1_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6697:1: ( rule__TypeNameExpCS__Group_1_1__1__Impl rule__TypeNameExpCS__Group_1_1__2 ) |
| // InternalEssentialOCL.g:6698:2: rule__TypeNameExpCS__Group_1_1__1__Impl rule__TypeNameExpCS__Group_1_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_21); |
| rule__TypeNameExpCS__Group_1_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__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__TypeNameExpCS__Group_1_1__1" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group_1_1__1__Impl" |
| // InternalEssentialOCL.g:6705:1: rule__TypeNameExpCS__Group_1_1__1__Impl : ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) ) ; |
| public final void rule__TypeNameExpCS__Group_1_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6709:1: ( ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) ) ) |
| // InternalEssentialOCL.g:6710:1: ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:6710:1: ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) ) |
| // InternalEssentialOCL.g:6711:1: ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardAssignment_1_1_1()); |
| } |
| // InternalEssentialOCL.g:6712:1: ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) |
| // InternalEssentialOCL.g:6712:2: rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardAssignment_1_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__Group_1_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group_1_1__2" |
| // InternalEssentialOCL.g:6722:1: rule__TypeNameExpCS__Group_1_1__2 : rule__TypeNameExpCS__Group_1_1__2__Impl ; |
| public final void rule__TypeNameExpCS__Group_1_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6726:1: ( rule__TypeNameExpCS__Group_1_1__2__Impl ) |
| // InternalEssentialOCL.g:6727:2: rule__TypeNameExpCS__Group_1_1__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeNameExpCS__Group_1_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__Group_1_1__2" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__Group_1_1__2__Impl" |
| // InternalEssentialOCL.g:6733:1: rule__TypeNameExpCS__Group_1_1__2__Impl : ( '}' ) ; |
| public final void rule__TypeNameExpCS__Group_1_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6737:1: ( ( '}' ) ) |
| // InternalEssentialOCL.g:6738:1: ( '}' ) |
| { |
| // InternalEssentialOCL.g:6738:1: ( '}' ) |
| // InternalEssentialOCL.g:6739:1: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSAccess().getRightCurlyBracketKeyword_1_1_2()); |
| } |
| match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSAccess().getRightCurlyBracketKeyword_1_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__Group_1_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__TypeExpCS__Group__0" |
| // InternalEssentialOCL.g:6758:1: rule__TypeExpCS__Group__0 : rule__TypeExpCS__Group__0__Impl rule__TypeExpCS__Group__1 ; |
| public final void rule__TypeExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6762:1: ( rule__TypeExpCS__Group__0__Impl rule__TypeExpCS__Group__1 ) |
| // InternalEssentialOCL.g:6763:2: rule__TypeExpCS__Group__0__Impl rule__TypeExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_29); |
| rule__TypeExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__TypeExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:6770:1: rule__TypeExpCS__Group__0__Impl : ( ruleTypeExpWithoutMultiplicityCS ) ; |
| public final void rule__TypeExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6774:1: ( ( ruleTypeExpWithoutMultiplicityCS ) ) |
| // InternalEssentialOCL.g:6775:1: ( ruleTypeExpWithoutMultiplicityCS ) |
| { |
| // InternalEssentialOCL.g:6775:1: ( ruleTypeExpWithoutMultiplicityCS ) |
| // InternalEssentialOCL.g:6776:1: ruleTypeExpWithoutMultiplicityCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeExpCSAccess().getTypeExpWithoutMultiplicityCSParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpWithoutMultiplicityCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeExpCSAccess().getTypeExpWithoutMultiplicityCSParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TypeExpCS__Group__1" |
| // InternalEssentialOCL.g:6787:1: rule__TypeExpCS__Group__1 : rule__TypeExpCS__Group__1__Impl ; |
| public final void rule__TypeExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6791:1: ( rule__TypeExpCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:6792:2: rule__TypeExpCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__TypeExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:6798:1: rule__TypeExpCS__Group__1__Impl : ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? ) ; |
| public final void rule__TypeExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6802:1: ( ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? ) ) |
| // InternalEssentialOCL.g:6803:1: ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? ) |
| { |
| // InternalEssentialOCL.g:6803:1: ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? ) |
| // InternalEssentialOCL.g:6804:1: ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityAssignment_1()); |
| } |
| // InternalEssentialOCL.g:6805:1: ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? |
| int alt58=2; |
| int LA58_0 = input.LA(1); |
| |
| if ( (LA58_0==71) ) { |
| alt58=1; |
| } |
| switch (alt58) { |
| case 1 : |
| // InternalEssentialOCL.g:6805:2: rule__TypeExpCS__OwnedMultiplicityAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeExpCS__OwnedMultiplicityAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__ExpCS__Group_0__0" |
| // InternalEssentialOCL.g:6819:1: rule__ExpCS__Group_0__0 : rule__ExpCS__Group_0__0__Impl rule__ExpCS__Group_0__1 ; |
| public final void rule__ExpCS__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6823:1: ( rule__ExpCS__Group_0__0__Impl rule__ExpCS__Group_0__1 ) |
| // InternalEssentialOCL.g:6824:2: rule__ExpCS__Group_0__0__Impl rule__ExpCS__Group_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_30); |
| rule__ExpCS__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ExpCS__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__Group_0__0" |
| |
| |
| // $ANTLR start "rule__ExpCS__Group_0__0__Impl" |
| // InternalEssentialOCL.g:6831:1: rule__ExpCS__Group_0__0__Impl : ( rulePrefixedPrimaryExpCS ) ; |
| public final void rule__ExpCS__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6835:1: ( ( rulePrefixedPrimaryExpCS ) ) |
| // InternalEssentialOCL.g:6836:1: ( rulePrefixedPrimaryExpCS ) |
| { |
| // InternalEssentialOCL.g:6836:1: ( rulePrefixedPrimaryExpCS ) |
| // InternalEssentialOCL.g:6837:1: rulePrefixedPrimaryExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSAccess().getPrefixedPrimaryExpCSParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePrefixedPrimaryExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpCSAccess().getPrefixedPrimaryExpCSParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__ExpCS__Group_0__1" |
| // InternalEssentialOCL.g:6848:1: rule__ExpCS__Group_0__1 : rule__ExpCS__Group_0__1__Impl ; |
| public final void rule__ExpCS__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6852:1: ( rule__ExpCS__Group_0__1__Impl ) |
| // InternalEssentialOCL.g:6853:2: rule__ExpCS__Group_0__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ExpCS__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__ExpCS__Group_0__1" |
| |
| |
| // $ANTLR start "rule__ExpCS__Group_0__1__Impl" |
| // InternalEssentialOCL.g:6859:1: rule__ExpCS__Group_0__1__Impl : ( ( rule__ExpCS__Group_0_1__0 )? ) ; |
| public final void rule__ExpCS__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6863:1: ( ( ( rule__ExpCS__Group_0_1__0 )? ) ) |
| // InternalEssentialOCL.g:6864:1: ( ( rule__ExpCS__Group_0_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:6864:1: ( ( rule__ExpCS__Group_0_1__0 )? ) |
| // InternalEssentialOCL.g:6865:1: ( rule__ExpCS__Group_0_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSAccess().getGroup_0_1()); |
| } |
| // InternalEssentialOCL.g:6866:1: ( rule__ExpCS__Group_0_1__0 )? |
| int alt59=2; |
| int LA59_0 = input.LA(1); |
| |
| if ( (LA59_0==16||(LA59_0>=19 && LA59_0<=39)) ) { |
| alt59=1; |
| } |
| switch (alt59) { |
| case 1 : |
| // InternalEssentialOCL.g:6866:2: rule__ExpCS__Group_0_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ExpCS__Group_0_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpCSAccess().getGroup_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__ExpCS__Group_0_1__0" |
| // InternalEssentialOCL.g:6880:1: rule__ExpCS__Group_0_1__0 : rule__ExpCS__Group_0_1__0__Impl rule__ExpCS__Group_0_1__1 ; |
| public final void rule__ExpCS__Group_0_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6884:1: ( rule__ExpCS__Group_0_1__0__Impl rule__ExpCS__Group_0_1__1 ) |
| // InternalEssentialOCL.g:6885:2: rule__ExpCS__Group_0_1__0__Impl rule__ExpCS__Group_0_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_30); |
| rule__ExpCS__Group_0_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ExpCS__Group_0_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__Group_0_1__0" |
| |
| |
| // $ANTLR start "rule__ExpCS__Group_0_1__0__Impl" |
| // InternalEssentialOCL.g:6892:1: rule__ExpCS__Group_0_1__0__Impl : ( () ) ; |
| public final void rule__ExpCS__Group_0_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6896:1: ( ( () ) ) |
| // InternalEssentialOCL.g:6897:1: ( () ) |
| { |
| // InternalEssentialOCL.g:6897:1: ( () ) |
| // InternalEssentialOCL.g:6898:1: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSAccess().getInfixExpCSOwnedLeftAction_0_1_0()); |
| } |
| // InternalEssentialOCL.g:6899:1: () |
| // InternalEssentialOCL.g:6901:1: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpCSAccess().getInfixExpCSOwnedLeftAction_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__Group_0_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__ExpCS__Group_0_1__1" |
| // InternalEssentialOCL.g:6911:1: rule__ExpCS__Group_0_1__1 : rule__ExpCS__Group_0_1__1__Impl rule__ExpCS__Group_0_1__2 ; |
| public final void rule__ExpCS__Group_0_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6915:1: ( rule__ExpCS__Group_0_1__1__Impl rule__ExpCS__Group_0_1__2 ) |
| // InternalEssentialOCL.g:6916:2: rule__ExpCS__Group_0_1__1__Impl rule__ExpCS__Group_0_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__ExpCS__Group_0_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ExpCS__Group_0_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__Group_0_1__1" |
| |
| |
| // $ANTLR start "rule__ExpCS__Group_0_1__1__Impl" |
| // InternalEssentialOCL.g:6923:1: rule__ExpCS__Group_0_1__1__Impl : ( ( rule__ExpCS__NameAssignment_0_1_1 ) ) ; |
| public final void rule__ExpCS__Group_0_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6927:1: ( ( ( rule__ExpCS__NameAssignment_0_1_1 ) ) ) |
| // InternalEssentialOCL.g:6928:1: ( ( rule__ExpCS__NameAssignment_0_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:6928:1: ( ( rule__ExpCS__NameAssignment_0_1_1 ) ) |
| // InternalEssentialOCL.g:6929:1: ( rule__ExpCS__NameAssignment_0_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSAccess().getNameAssignment_0_1_1()); |
| } |
| // InternalEssentialOCL.g:6930:1: ( rule__ExpCS__NameAssignment_0_1_1 ) |
| // InternalEssentialOCL.g:6930:2: rule__ExpCS__NameAssignment_0_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ExpCS__NameAssignment_0_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpCSAccess().getNameAssignment_0_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__Group_0_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__ExpCS__Group_0_1__2" |
| // InternalEssentialOCL.g:6940:1: rule__ExpCS__Group_0_1__2 : rule__ExpCS__Group_0_1__2__Impl ; |
| public final void rule__ExpCS__Group_0_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6944:1: ( rule__ExpCS__Group_0_1__2__Impl ) |
| // InternalEssentialOCL.g:6945:2: rule__ExpCS__Group_0_1__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ExpCS__Group_0_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__Group_0_1__2" |
| |
| |
| // $ANTLR start "rule__ExpCS__Group_0_1__2__Impl" |
| // InternalEssentialOCL.g:6951:1: rule__ExpCS__Group_0_1__2__Impl : ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) ) ; |
| public final void rule__ExpCS__Group_0_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6955:1: ( ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) ) ) |
| // InternalEssentialOCL.g:6956:1: ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) ) |
| { |
| // InternalEssentialOCL.g:6956:1: ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) ) |
| // InternalEssentialOCL.g:6957:1: ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSAccess().getOwnedRightAssignment_0_1_2()); |
| } |
| // InternalEssentialOCL.g:6958:1: ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) |
| // InternalEssentialOCL.g:6958:2: rule__ExpCS__OwnedRightAssignment_0_1_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ExpCS__OwnedRightAssignment_0_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpCSAccess().getOwnedRightAssignment_0_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__Group_0_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__PrefixedLetExpCS__Group_0__0" |
| // InternalEssentialOCL.g:6974:1: rule__PrefixedLetExpCS__Group_0__0 : rule__PrefixedLetExpCS__Group_0__0__Impl rule__PrefixedLetExpCS__Group_0__1 ; |
| public final void rule__PrefixedLetExpCS__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6978:1: ( rule__PrefixedLetExpCS__Group_0__0__Impl rule__PrefixedLetExpCS__Group_0__1 ) |
| // InternalEssentialOCL.g:6979:2: rule__PrefixedLetExpCS__Group_0__0__Impl rule__PrefixedLetExpCS__Group_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_31); |
| rule__PrefixedLetExpCS__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedLetExpCS__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedLetExpCS__Group_0__0" |
| |
| |
| // $ANTLR start "rule__PrefixedLetExpCS__Group_0__0__Impl" |
| // InternalEssentialOCL.g:6986:1: rule__PrefixedLetExpCS__Group_0__0__Impl : ( () ) ; |
| public final void rule__PrefixedLetExpCS__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:6990:1: ( ( () ) ) |
| // InternalEssentialOCL.g:6991:1: ( () ) |
| { |
| // InternalEssentialOCL.g:6991:1: ( () ) |
| // InternalEssentialOCL.g:6992:1: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedLetExpCSAccess().getPrefixExpCSAction_0_0()); |
| } |
| // InternalEssentialOCL.g:6993:1: () |
| // InternalEssentialOCL.g:6995:1: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedLetExpCSAccess().getPrefixExpCSAction_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedLetExpCS__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__PrefixedLetExpCS__Group_0__1" |
| // InternalEssentialOCL.g:7005:1: rule__PrefixedLetExpCS__Group_0__1 : rule__PrefixedLetExpCS__Group_0__1__Impl rule__PrefixedLetExpCS__Group_0__2 ; |
| public final void rule__PrefixedLetExpCS__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7009:1: ( rule__PrefixedLetExpCS__Group_0__1__Impl rule__PrefixedLetExpCS__Group_0__2 ) |
| // InternalEssentialOCL.g:7010:2: rule__PrefixedLetExpCS__Group_0__1__Impl rule__PrefixedLetExpCS__Group_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__PrefixedLetExpCS__Group_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedLetExpCS__Group_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedLetExpCS__Group_0__1" |
| |
| |
| // $ANTLR start "rule__PrefixedLetExpCS__Group_0__1__Impl" |
| // InternalEssentialOCL.g:7017:1: rule__PrefixedLetExpCS__Group_0__1__Impl : ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) ) ; |
| public final void rule__PrefixedLetExpCS__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7021:1: ( ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) ) ) |
| // InternalEssentialOCL.g:7022:1: ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) ) |
| { |
| // InternalEssentialOCL.g:7022:1: ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) ) |
| // InternalEssentialOCL.g:7023:1: ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedLetExpCSAccess().getNameAssignment_0_1()); |
| } |
| // InternalEssentialOCL.g:7024:1: ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) |
| // InternalEssentialOCL.g:7024:2: rule__PrefixedLetExpCS__NameAssignment_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedLetExpCS__NameAssignment_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedLetExpCSAccess().getNameAssignment_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedLetExpCS__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__PrefixedLetExpCS__Group_0__2" |
| // InternalEssentialOCL.g:7034:1: rule__PrefixedLetExpCS__Group_0__2 : rule__PrefixedLetExpCS__Group_0__2__Impl ; |
| public final void rule__PrefixedLetExpCS__Group_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7038:1: ( rule__PrefixedLetExpCS__Group_0__2__Impl ) |
| // InternalEssentialOCL.g:7039:2: rule__PrefixedLetExpCS__Group_0__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedLetExpCS__Group_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedLetExpCS__Group_0__2" |
| |
| |
| // $ANTLR start "rule__PrefixedLetExpCS__Group_0__2__Impl" |
| // InternalEssentialOCL.g:7045:1: rule__PrefixedLetExpCS__Group_0__2__Impl : ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) ) ; |
| public final void rule__PrefixedLetExpCS__Group_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7049:1: ( ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) ) ) |
| // InternalEssentialOCL.g:7050:1: ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) ) |
| { |
| // InternalEssentialOCL.g:7050:1: ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) ) |
| // InternalEssentialOCL.g:7051:1: ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightAssignment_0_2()); |
| } |
| // InternalEssentialOCL.g:7052:1: ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) |
| // InternalEssentialOCL.g:7052:2: rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedLetExpCS__OwnedRightAssignment_0_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightAssignment_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedLetExpCS__Group_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__0" |
| // InternalEssentialOCL.g:7068:1: rule__PrefixedPrimaryExpCS__Group_0__0 : rule__PrefixedPrimaryExpCS__Group_0__0__Impl rule__PrefixedPrimaryExpCS__Group_0__1 ; |
| public final void rule__PrefixedPrimaryExpCS__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7072:1: ( rule__PrefixedPrimaryExpCS__Group_0__0__Impl rule__PrefixedPrimaryExpCS__Group_0__1 ) |
| // InternalEssentialOCL.g:7073:2: rule__PrefixedPrimaryExpCS__Group_0__0__Impl rule__PrefixedPrimaryExpCS__Group_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_31); |
| rule__PrefixedPrimaryExpCS__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedPrimaryExpCS__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__0" |
| |
| |
| // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__0__Impl" |
| // InternalEssentialOCL.g:7080:1: rule__PrefixedPrimaryExpCS__Group_0__0__Impl : ( () ) ; |
| public final void rule__PrefixedPrimaryExpCS__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7084:1: ( ( () ) ) |
| // InternalEssentialOCL.g:7085:1: ( () ) |
| { |
| // InternalEssentialOCL.g:7085:1: ( () ) |
| // InternalEssentialOCL.g:7086:1: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrefixExpCSAction_0_0()); |
| } |
| // InternalEssentialOCL.g:7087:1: () |
| // InternalEssentialOCL.g:7089:1: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrefixExpCSAction_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__1" |
| // InternalEssentialOCL.g:7099:1: rule__PrefixedPrimaryExpCS__Group_0__1 : rule__PrefixedPrimaryExpCS__Group_0__1__Impl rule__PrefixedPrimaryExpCS__Group_0__2 ; |
| public final void rule__PrefixedPrimaryExpCS__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7103:1: ( rule__PrefixedPrimaryExpCS__Group_0__1__Impl rule__PrefixedPrimaryExpCS__Group_0__2 ) |
| // InternalEssentialOCL.g:7104:2: rule__PrefixedPrimaryExpCS__Group_0__1__Impl rule__PrefixedPrimaryExpCS__Group_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_32); |
| rule__PrefixedPrimaryExpCS__Group_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedPrimaryExpCS__Group_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__1" |
| |
| |
| // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__1__Impl" |
| // InternalEssentialOCL.g:7111:1: rule__PrefixedPrimaryExpCS__Group_0__1__Impl : ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) ) ; |
| public final void rule__PrefixedPrimaryExpCS__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7115:1: ( ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) ) ) |
| // InternalEssentialOCL.g:7116:1: ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) ) |
| { |
| // InternalEssentialOCL.g:7116:1: ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) ) |
| // InternalEssentialOCL.g:7117:1: ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameAssignment_0_1()); |
| } |
| // InternalEssentialOCL.g:7118:1: ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) |
| // InternalEssentialOCL.g:7118:2: rule__PrefixedPrimaryExpCS__NameAssignment_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedPrimaryExpCS__NameAssignment_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameAssignment_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__2" |
| // InternalEssentialOCL.g:7128:1: rule__PrefixedPrimaryExpCS__Group_0__2 : rule__PrefixedPrimaryExpCS__Group_0__2__Impl ; |
| public final void rule__PrefixedPrimaryExpCS__Group_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7132:1: ( rule__PrefixedPrimaryExpCS__Group_0__2__Impl ) |
| // InternalEssentialOCL.g:7133:2: rule__PrefixedPrimaryExpCS__Group_0__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedPrimaryExpCS__Group_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__2" |
| |
| |
| // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__2__Impl" |
| // InternalEssentialOCL.g:7139:1: rule__PrefixedPrimaryExpCS__Group_0__2__Impl : ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) ) ; |
| public final void rule__PrefixedPrimaryExpCS__Group_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7143:1: ( ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) ) ) |
| // InternalEssentialOCL.g:7144:1: ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) ) |
| { |
| // InternalEssentialOCL.g:7144:1: ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) ) |
| // InternalEssentialOCL.g:7145:1: ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightAssignment_0_2()); |
| } |
| // InternalEssentialOCL.g:7146:1: ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) |
| // InternalEssentialOCL.g:7146:2: rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightAssignment_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group__0" |
| // InternalEssentialOCL.g:7162:1: rule__NameExpCS__Group__0 : rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1 ; |
| public final void rule__NameExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7166:1: ( rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1 ) |
| // InternalEssentialOCL.g:7167:2: rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_33); |
| rule__NameExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:7174:1: rule__NameExpCS__Group__0__Impl : ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) ) ; |
| public final void rule__NameExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7178:1: ( ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:7179:1: ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:7179:1: ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) ) |
| // InternalEssentialOCL.g:7180:1: ( rule__NameExpCS__OwnedPathNameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getOwnedPathNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:7181:1: ( rule__NameExpCS__OwnedPathNameAssignment_0 ) |
| // InternalEssentialOCL.g:7181:2: rule__NameExpCS__OwnedPathNameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__OwnedPathNameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getOwnedPathNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group__1" |
| // InternalEssentialOCL.g:7191:1: rule__NameExpCS__Group__1 : rule__NameExpCS__Group__1__Impl rule__NameExpCS__Group__2 ; |
| public final void rule__NameExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7195:1: ( rule__NameExpCS__Group__1__Impl rule__NameExpCS__Group__2 ) |
| // InternalEssentialOCL.g:7196:2: rule__NameExpCS__Group__1__Impl rule__NameExpCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_33); |
| rule__NameExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:7203:1: rule__NameExpCS__Group__1__Impl : ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* ) ; |
| public final void rule__NameExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7207:1: ( ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* ) ) |
| // InternalEssentialOCL.g:7208:1: ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* ) |
| { |
| // InternalEssentialOCL.g:7208:1: ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* ) |
| // InternalEssentialOCL.g:7209:1: ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesAssignment_1()); |
| } |
| // InternalEssentialOCL.g:7210:1: ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* |
| loop60: |
| do { |
| int alt60=2; |
| int LA60_0 = input.LA(1); |
| |
| if ( (LA60_0==71) ) { |
| alt60=1; |
| } |
| |
| |
| switch (alt60) { |
| case 1 : |
| // InternalEssentialOCL.g:7210:2: rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_34); |
| rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop60; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group__2" |
| // InternalEssentialOCL.g:7220:1: rule__NameExpCS__Group__2 : rule__NameExpCS__Group__2__Impl rule__NameExpCS__Group__3 ; |
| public final void rule__NameExpCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7224:1: ( rule__NameExpCS__Group__2__Impl rule__NameExpCS__Group__3 ) |
| // InternalEssentialOCL.g:7225:2: rule__NameExpCS__Group__2__Impl rule__NameExpCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_33); |
| rule__NameExpCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group__2" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group__2__Impl" |
| // InternalEssentialOCL.g:7232:1: rule__NameExpCS__Group__2__Impl : ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? ) ; |
| public final void rule__NameExpCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7236:1: ( ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? ) ) |
| // InternalEssentialOCL.g:7237:1: ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? ) |
| { |
| // InternalEssentialOCL.g:7237:1: ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? ) |
| // InternalEssentialOCL.g:7238:1: ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseAssignment_2()); |
| } |
| // InternalEssentialOCL.g:7239:1: ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? |
| int alt61=2; |
| int LA61_0 = input.LA(1); |
| |
| if ( (LA61_0==59) ) { |
| alt61=1; |
| } |
| switch (alt61) { |
| case 1 : |
| // InternalEssentialOCL.g:7239:2: rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group__3" |
| // InternalEssentialOCL.g:7249:1: rule__NameExpCS__Group__3 : rule__NameExpCS__Group__3__Impl rule__NameExpCS__Group__4 ; |
| public final void rule__NameExpCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7253:1: ( rule__NameExpCS__Group__3__Impl rule__NameExpCS__Group__4 ) |
| // InternalEssentialOCL.g:7254:2: rule__NameExpCS__Group__3__Impl rule__NameExpCS__Group__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_33); |
| rule__NameExpCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group__3" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group__3__Impl" |
| // InternalEssentialOCL.g:7261:1: rule__NameExpCS__Group__3__Impl : ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? ) ; |
| public final void rule__NameExpCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7265:1: ( ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? ) ) |
| // InternalEssentialOCL.g:7266:1: ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? ) |
| { |
| // InternalEssentialOCL.g:7266:1: ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? ) |
| // InternalEssentialOCL.g:7267:1: ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_3()); |
| } |
| // InternalEssentialOCL.g:7268:1: ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? |
| int alt62=2; |
| int LA62_0 = input.LA(1); |
| |
| if ( (LA62_0==63) ) { |
| alt62=1; |
| } |
| switch (alt62) { |
| case 1 : |
| // InternalEssentialOCL.g:7268:2: rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group__4" |
| // InternalEssentialOCL.g:7278:1: rule__NameExpCS__Group__4 : rule__NameExpCS__Group__4__Impl ; |
| public final void rule__NameExpCS__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7282:1: ( rule__NameExpCS__Group__4__Impl ) |
| // InternalEssentialOCL.g:7283:2: rule__NameExpCS__Group__4__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group__4" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group__4__Impl" |
| // InternalEssentialOCL.g:7289:1: rule__NameExpCS__Group__4__Impl : ( ( rule__NameExpCS__Group_4__0 )? ) ; |
| public final void rule__NameExpCS__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7293:1: ( ( ( rule__NameExpCS__Group_4__0 )? ) ) |
| // InternalEssentialOCL.g:7294:1: ( ( rule__NameExpCS__Group_4__0 )? ) |
| { |
| // InternalEssentialOCL.g:7294:1: ( ( rule__NameExpCS__Group_4__0 )? ) |
| // InternalEssentialOCL.g:7295:1: ( rule__NameExpCS__Group_4__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getGroup_4()); |
| } |
| // InternalEssentialOCL.g:7296:1: ( rule__NameExpCS__Group_4__0 )? |
| int alt63=2; |
| int LA63_0 = input.LA(1); |
| |
| if ( (LA63_0==86) ) { |
| alt63=1; |
| } |
| switch (alt63) { |
| case 1 : |
| // InternalEssentialOCL.g:7296:2: rule__NameExpCS__Group_4__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__Group_4__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getGroup_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group_4__0" |
| // InternalEssentialOCL.g:7316:1: rule__NameExpCS__Group_4__0 : rule__NameExpCS__Group_4__0__Impl rule__NameExpCS__Group_4__1 ; |
| public final void rule__NameExpCS__Group_4__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7320:1: ( rule__NameExpCS__Group_4__0__Impl rule__NameExpCS__Group_4__1 ) |
| // InternalEssentialOCL.g:7321:2: rule__NameExpCS__Group_4__0__Impl rule__NameExpCS__Group_4__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_35); |
| rule__NameExpCS__Group_4__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__Group_4__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group_4__0" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group_4__0__Impl" |
| // InternalEssentialOCL.g:7328:1: rule__NameExpCS__Group_4__0__Impl : ( ( rule__NameExpCS__IsPreAssignment_4_0 ) ) ; |
| public final void rule__NameExpCS__Group_4__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7332:1: ( ( ( rule__NameExpCS__IsPreAssignment_4_0 ) ) ) |
| // InternalEssentialOCL.g:7333:1: ( ( rule__NameExpCS__IsPreAssignment_4_0 ) ) |
| { |
| // InternalEssentialOCL.g:7333:1: ( ( rule__NameExpCS__IsPreAssignment_4_0 ) ) |
| // InternalEssentialOCL.g:7334:1: ( rule__NameExpCS__IsPreAssignment_4_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getIsPreAssignment_4_0()); |
| } |
| // InternalEssentialOCL.g:7335:1: ( rule__NameExpCS__IsPreAssignment_4_0 ) |
| // InternalEssentialOCL.g:7335:2: rule__NameExpCS__IsPreAssignment_4_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__IsPreAssignment_4_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getIsPreAssignment_4_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group_4__0__Impl" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group_4__1" |
| // InternalEssentialOCL.g:7345:1: rule__NameExpCS__Group_4__1 : rule__NameExpCS__Group_4__1__Impl ; |
| public final void rule__NameExpCS__Group_4__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7349:1: ( rule__NameExpCS__Group_4__1__Impl ) |
| // InternalEssentialOCL.g:7350:2: rule__NameExpCS__Group_4__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NameExpCS__Group_4__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group_4__1" |
| |
| |
| // $ANTLR start "rule__NameExpCS__Group_4__1__Impl" |
| // InternalEssentialOCL.g:7356:1: rule__NameExpCS__Group_4__1__Impl : ( 'pre' ) ; |
| public final void rule__NameExpCS__Group_4__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7360:1: ( ( 'pre' ) ) |
| // InternalEssentialOCL.g:7361:1: ( 'pre' ) |
| { |
| // InternalEssentialOCL.g:7361:1: ( 'pre' ) |
| // InternalEssentialOCL.g:7362:1: 'pre' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getPreKeyword_4_1()); |
| } |
| match(input,70,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getPreKeyword_4_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__Group_4__1__Impl" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group__0" |
| // InternalEssentialOCL.g:7379:1: rule__CurlyBracketedClauseCS__Group__0 : rule__CurlyBracketedClauseCS__Group__0__Impl rule__CurlyBracketedClauseCS__Group__1 ; |
| public final void rule__CurlyBracketedClauseCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7383:1: ( rule__CurlyBracketedClauseCS__Group__0__Impl rule__CurlyBracketedClauseCS__Group__1 ) |
| // InternalEssentialOCL.g:7384:2: rule__CurlyBracketedClauseCS__Group__0__Impl rule__CurlyBracketedClauseCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_14); |
| rule__CurlyBracketedClauseCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group__0" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group__0__Impl" |
| // InternalEssentialOCL.g:7391:1: rule__CurlyBracketedClauseCS__Group__0__Impl : ( () ) ; |
| public final void rule__CurlyBracketedClauseCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7395:1: ( ( () ) ) |
| // InternalEssentialOCL.g:7396:1: ( () ) |
| { |
| // InternalEssentialOCL.g:7396:1: ( () ) |
| // InternalEssentialOCL.g:7397:1: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSAccess().getCurlyBracketedClauseCSAction_0()); |
| } |
| // InternalEssentialOCL.g:7398:1: () |
| // InternalEssentialOCL.g:7400:1: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSAccess().getCurlyBracketedClauseCSAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group__1" |
| // InternalEssentialOCL.g:7410:1: rule__CurlyBracketedClauseCS__Group__1 : rule__CurlyBracketedClauseCS__Group__1__Impl rule__CurlyBracketedClauseCS__Group__2 ; |
| public final void rule__CurlyBracketedClauseCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7414:1: ( rule__CurlyBracketedClauseCS__Group__1__Impl rule__CurlyBracketedClauseCS__Group__2 ) |
| // InternalEssentialOCL.g:7415:2: rule__CurlyBracketedClauseCS__Group__1__Impl rule__CurlyBracketedClauseCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_36); |
| rule__CurlyBracketedClauseCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group__1" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group__1__Impl" |
| // InternalEssentialOCL.g:7422:1: rule__CurlyBracketedClauseCS__Group__1__Impl : ( '{' ) ; |
| public final void rule__CurlyBracketedClauseCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7426:1: ( ( '{' ) ) |
| // InternalEssentialOCL.g:7427:1: ( '{' ) |
| { |
| // InternalEssentialOCL.g:7427:1: ( '{' ) |
| // InternalEssentialOCL.g:7428:1: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSAccess().getLeftCurlyBracketKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group__2" |
| // InternalEssentialOCL.g:7441:1: rule__CurlyBracketedClauseCS__Group__2 : rule__CurlyBracketedClauseCS__Group__2__Impl rule__CurlyBracketedClauseCS__Group__3 ; |
| public final void rule__CurlyBracketedClauseCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7445:1: ( rule__CurlyBracketedClauseCS__Group__2__Impl rule__CurlyBracketedClauseCS__Group__3 ) |
| // InternalEssentialOCL.g:7446:2: rule__CurlyBracketedClauseCS__Group__2__Impl rule__CurlyBracketedClauseCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_36); |
| rule__CurlyBracketedClauseCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group__2" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group__2__Impl" |
| // InternalEssentialOCL.g:7453:1: rule__CurlyBracketedClauseCS__Group__2__Impl : ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? ) ; |
| public final void rule__CurlyBracketedClauseCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7457:1: ( ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? ) ) |
| // InternalEssentialOCL.g:7458:1: ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:7458:1: ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? ) |
| // InternalEssentialOCL.g:7459:1: ( rule__CurlyBracketedClauseCS__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2()); |
| } |
| // InternalEssentialOCL.g:7460:1: ( rule__CurlyBracketedClauseCS__Group_2__0 )? |
| int alt64=2; |
| int LA64_0 = input.LA(1); |
| |
| if ( ((LA64_0>=RULE_SINGLE_QUOTED_STRING && LA64_0<=RULE_ESCAPED_ID)) ) { |
| alt64=1; |
| } |
| switch (alt64) { |
| case 1 : |
| // InternalEssentialOCL.g:7460:2: rule__CurlyBracketedClauseCS__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group__3" |
| // InternalEssentialOCL.g:7470:1: rule__CurlyBracketedClauseCS__Group__3 : rule__CurlyBracketedClauseCS__Group__3__Impl ; |
| public final void rule__CurlyBracketedClauseCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7474:1: ( rule__CurlyBracketedClauseCS__Group__3__Impl ) |
| // InternalEssentialOCL.g:7475:2: rule__CurlyBracketedClauseCS__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group__3" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group__3__Impl" |
| // InternalEssentialOCL.g:7481:1: rule__CurlyBracketedClauseCS__Group__3__Impl : ( '}' ) ; |
| public final void rule__CurlyBracketedClauseCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7485:1: ( ( '}' ) ) |
| // InternalEssentialOCL.g:7486:1: ( '}' ) |
| { |
| // InternalEssentialOCL.g:7486:1: ( '}' ) |
| // InternalEssentialOCL.g:7487:1: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSAccess().getRightCurlyBracketKeyword_3()); |
| } |
| match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSAccess().getRightCurlyBracketKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__0" |
| // InternalEssentialOCL.g:7508:1: rule__CurlyBracketedClauseCS__Group_2__0 : rule__CurlyBracketedClauseCS__Group_2__0__Impl rule__CurlyBracketedClauseCS__Group_2__1 ; |
| public final void rule__CurlyBracketedClauseCS__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7512:1: ( rule__CurlyBracketedClauseCS__Group_2__0__Impl rule__CurlyBracketedClauseCS__Group_2__1 ) |
| // InternalEssentialOCL.g:7513:2: rule__CurlyBracketedClauseCS__Group_2__0__Impl rule__CurlyBracketedClauseCS__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_8); |
| rule__CurlyBracketedClauseCS__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2__0" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__0__Impl" |
| // InternalEssentialOCL.g:7520:1: rule__CurlyBracketedClauseCS__Group_2__0__Impl : ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) ) ; |
| public final void rule__CurlyBracketedClauseCS__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7524:1: ( ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) ) ) |
| // InternalEssentialOCL.g:7525:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) ) |
| { |
| // InternalEssentialOCL.g:7525:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) ) |
| // InternalEssentialOCL.g:7526:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_0()); |
| } |
| // InternalEssentialOCL.g:7527:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) |
| // InternalEssentialOCL.g:7527:2: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__1" |
| // InternalEssentialOCL.g:7537:1: rule__CurlyBracketedClauseCS__Group_2__1 : rule__CurlyBracketedClauseCS__Group_2__1__Impl ; |
| public final void rule__CurlyBracketedClauseCS__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7541:1: ( rule__CurlyBracketedClauseCS__Group_2__1__Impl ) |
| // InternalEssentialOCL.g:7542:2: rule__CurlyBracketedClauseCS__Group_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__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__CurlyBracketedClauseCS__Group_2__1" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__1__Impl" |
| // InternalEssentialOCL.g:7548:1: rule__CurlyBracketedClauseCS__Group_2__1__Impl : ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* ) ; |
| public final void rule__CurlyBracketedClauseCS__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7552:1: ( ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* ) ) |
| // InternalEssentialOCL.g:7553:1: ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* ) |
| { |
| // InternalEssentialOCL.g:7553:1: ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* ) |
| // InternalEssentialOCL.g:7554:1: ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2_1()); |
| } |
| // InternalEssentialOCL.g:7555:1: ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* |
| loop65: |
| do { |
| int alt65=2; |
| int LA65_0 = input.LA(1); |
| |
| if ( (LA65_0==61) ) { |
| alt65=1; |
| } |
| |
| |
| switch (alt65) { |
| case 1 : |
| // InternalEssentialOCL.g:7555:2: rule__CurlyBracketedClauseCS__Group_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_11); |
| rule__CurlyBracketedClauseCS__Group_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop65; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__0" |
| // InternalEssentialOCL.g:7569:1: rule__CurlyBracketedClauseCS__Group_2_1__0 : rule__CurlyBracketedClauseCS__Group_2_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_1__1 ; |
| public final void rule__CurlyBracketedClauseCS__Group_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7573:1: ( rule__CurlyBracketedClauseCS__Group_2_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_1__1 ) |
| // InternalEssentialOCL.g:7574:2: rule__CurlyBracketedClauseCS__Group_2_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_37); |
| rule__CurlyBracketedClauseCS__Group_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__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__CurlyBracketedClauseCS__Group_2_1__0" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__0__Impl" |
| // InternalEssentialOCL.g:7581:1: rule__CurlyBracketedClauseCS__Group_2_1__0__Impl : ( ',' ) ; |
| public final void rule__CurlyBracketedClauseCS__Group_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7585:1: ( ( ',' ) ) |
| // InternalEssentialOCL.g:7586:1: ( ',' ) |
| { |
| // InternalEssentialOCL.g:7586:1: ( ',' ) |
| // InternalEssentialOCL.g:7587:1: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSAccess().getCommaKeyword_2_1_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSAccess().getCommaKeyword_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__1" |
| // InternalEssentialOCL.g:7600:1: rule__CurlyBracketedClauseCS__Group_2_1__1 : rule__CurlyBracketedClauseCS__Group_2_1__1__Impl ; |
| public final void rule__CurlyBracketedClauseCS__Group_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7604:1: ( rule__CurlyBracketedClauseCS__Group_2_1__1__Impl ) |
| // InternalEssentialOCL.g:7605:2: rule__CurlyBracketedClauseCS__Group_2_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__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__CurlyBracketedClauseCS__Group_2_1__1" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__1__Impl" |
| // InternalEssentialOCL.g:7611:1: rule__CurlyBracketedClauseCS__Group_2_1__1__Impl : ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) ) ; |
| public final void rule__CurlyBracketedClauseCS__Group_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7615:1: ( ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) ) ) |
| // InternalEssentialOCL.g:7616:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:7616:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) ) |
| // InternalEssentialOCL.g:7617:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_1_1()); |
| } |
| // InternalEssentialOCL.g:7618:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) |
| // InternalEssentialOCL.g:7618:2: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group__0" |
| // InternalEssentialOCL.g:7632:1: rule__RoundBracketedClauseCS__Group__0 : rule__RoundBracketedClauseCS__Group__0__Impl rule__RoundBracketedClauseCS__Group__1 ; |
| public final void rule__RoundBracketedClauseCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7636:1: ( rule__RoundBracketedClauseCS__Group__0__Impl rule__RoundBracketedClauseCS__Group__1 ) |
| // InternalEssentialOCL.g:7637:2: rule__RoundBracketedClauseCS__Group__0__Impl rule__RoundBracketedClauseCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_5); |
| rule__RoundBracketedClauseCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RoundBracketedClauseCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__Group__0" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group__0__Impl" |
| // InternalEssentialOCL.g:7644:1: rule__RoundBracketedClauseCS__Group__0__Impl : ( () ) ; |
| public final void rule__RoundBracketedClauseCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7648:1: ( ( () ) ) |
| // InternalEssentialOCL.g:7649:1: ( () ) |
| { |
| // InternalEssentialOCL.g:7649:1: ( () ) |
| // InternalEssentialOCL.g:7650:1: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getRoundBracketedClauseCSAction_0()); |
| } |
| // InternalEssentialOCL.g:7651:1: () |
| // InternalEssentialOCL.g:7653:1: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getRoundBracketedClauseCSAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group__1" |
| // InternalEssentialOCL.g:7663:1: rule__RoundBracketedClauseCS__Group__1 : rule__RoundBracketedClauseCS__Group__1__Impl rule__RoundBracketedClauseCS__Group__2 ; |
| public final void rule__RoundBracketedClauseCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7667:1: ( rule__RoundBracketedClauseCS__Group__1__Impl rule__RoundBracketedClauseCS__Group__2 ) |
| // InternalEssentialOCL.g:7668:2: rule__RoundBracketedClauseCS__Group__1__Impl rule__RoundBracketedClauseCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_38); |
| rule__RoundBracketedClauseCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RoundBracketedClauseCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__Group__1" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group__1__Impl" |
| // InternalEssentialOCL.g:7675:1: rule__RoundBracketedClauseCS__Group__1__Impl : ( '(' ) ; |
| public final void rule__RoundBracketedClauseCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7679:1: ( ( '(' ) ) |
| // InternalEssentialOCL.g:7680:1: ( '(' ) |
| { |
| // InternalEssentialOCL.g:7680:1: ( '(' ) |
| // InternalEssentialOCL.g:7681:1: '(' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getLeftParenthesisKeyword_1()); |
| } |
| match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getLeftParenthesisKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group__2" |
| // InternalEssentialOCL.g:7694:1: rule__RoundBracketedClauseCS__Group__2 : rule__RoundBracketedClauseCS__Group__2__Impl rule__RoundBracketedClauseCS__Group__3 ; |
| public final void rule__RoundBracketedClauseCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7698:1: ( rule__RoundBracketedClauseCS__Group__2__Impl rule__RoundBracketedClauseCS__Group__3 ) |
| // InternalEssentialOCL.g:7699:2: rule__RoundBracketedClauseCS__Group__2__Impl rule__RoundBracketedClauseCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_38); |
| rule__RoundBracketedClauseCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RoundBracketedClauseCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__Group__2" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group__2__Impl" |
| // InternalEssentialOCL.g:7706:1: rule__RoundBracketedClauseCS__Group__2__Impl : ( ( rule__RoundBracketedClauseCS__Group_2__0 )? ) ; |
| public final void rule__RoundBracketedClauseCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7710:1: ( ( ( rule__RoundBracketedClauseCS__Group_2__0 )? ) ) |
| // InternalEssentialOCL.g:7711:1: ( ( rule__RoundBracketedClauseCS__Group_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:7711:1: ( ( rule__RoundBracketedClauseCS__Group_2__0 )? ) |
| // InternalEssentialOCL.g:7712:1: ( rule__RoundBracketedClauseCS__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getGroup_2()); |
| } |
| // InternalEssentialOCL.g:7713:1: ( rule__RoundBracketedClauseCS__Group_2__0 )? |
| int alt66=2; |
| int LA66_0 = input.LA(1); |
| |
| if ( ((LA66_0>=RULE_INT && LA66_0<=RULE_ESCAPED_ID)||(LA66_0>=16 && LA66_0<=19)||(LA66_0>=40 && LA66_0<=54)||LA66_0==59||LA66_0==62||(LA66_0>=67 && LA66_0<=69)||LA66_0==74||(LA66_0>=79 && LA66_0<=80)||(LA66_0>=84 && LA66_0<=85)) ) { |
| alt66=1; |
| } |
| switch (alt66) { |
| case 1 : |
| // InternalEssentialOCL.g:7713:2: rule__RoundBracketedClauseCS__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RoundBracketedClauseCS__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group__3" |
| // InternalEssentialOCL.g:7723:1: rule__RoundBracketedClauseCS__Group__3 : rule__RoundBracketedClauseCS__Group__3__Impl ; |
| public final void rule__RoundBracketedClauseCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7727:1: ( rule__RoundBracketedClauseCS__Group__3__Impl ) |
| // InternalEssentialOCL.g:7728:2: rule__RoundBracketedClauseCS__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RoundBracketedClauseCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__Group__3" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group__3__Impl" |
| // InternalEssentialOCL.g:7734:1: rule__RoundBracketedClauseCS__Group__3__Impl : ( ')' ) ; |
| public final void rule__RoundBracketedClauseCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7738:1: ( ( ')' ) ) |
| // InternalEssentialOCL.g:7739:1: ( ')' ) |
| { |
| // InternalEssentialOCL.g:7739:1: ( ')' ) |
| // InternalEssentialOCL.g:7740:1: ')' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getRightParenthesisKeyword_3()); |
| } |
| match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getRightParenthesisKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__0" |
| // InternalEssentialOCL.g:7761:1: rule__RoundBracketedClauseCS__Group_2__0 : rule__RoundBracketedClauseCS__Group_2__0__Impl rule__RoundBracketedClauseCS__Group_2__1 ; |
| public final void rule__RoundBracketedClauseCS__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7765:1: ( rule__RoundBracketedClauseCS__Group_2__0__Impl rule__RoundBracketedClauseCS__Group_2__1 ) |
| // InternalEssentialOCL.g:7766:2: rule__RoundBracketedClauseCS__Group_2__0__Impl rule__RoundBracketedClauseCS__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_39); |
| rule__RoundBracketedClauseCS__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RoundBracketedClauseCS__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__Group_2__0" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__0__Impl" |
| // InternalEssentialOCL.g:7773:1: rule__RoundBracketedClauseCS__Group_2__0__Impl : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) ) ; |
| public final void rule__RoundBracketedClauseCS__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7777:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) ) ) |
| // InternalEssentialOCL.g:7778:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) ) |
| { |
| // InternalEssentialOCL.g:7778:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) ) |
| // InternalEssentialOCL.g:7779:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_0()); |
| } |
| // InternalEssentialOCL.g:7780:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) |
| // InternalEssentialOCL.g:7780:2: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__1" |
| // InternalEssentialOCL.g:7790:1: rule__RoundBracketedClauseCS__Group_2__1 : rule__RoundBracketedClauseCS__Group_2__1__Impl ; |
| public final void rule__RoundBracketedClauseCS__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7794:1: ( rule__RoundBracketedClauseCS__Group_2__1__Impl ) |
| // InternalEssentialOCL.g:7795:2: rule__RoundBracketedClauseCS__Group_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RoundBracketedClauseCS__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__RoundBracketedClauseCS__Group_2__1" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__1__Impl" |
| // InternalEssentialOCL.g:7801:1: rule__RoundBracketedClauseCS__Group_2__1__Impl : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* ) ; |
| public final void rule__RoundBracketedClauseCS__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7805:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* ) ) |
| // InternalEssentialOCL.g:7806:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* ) |
| { |
| // InternalEssentialOCL.g:7806:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* ) |
| // InternalEssentialOCL.g:7807:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_1()); |
| } |
| // InternalEssentialOCL.g:7808:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* |
| loop67: |
| do { |
| int alt67=2; |
| int LA67_0 = input.LA(1); |
| |
| if ( (LA67_0==61||(LA67_0>=87 && LA67_0<=88)) ) { |
| alt67=1; |
| } |
| |
| |
| switch (alt67) { |
| case 1 : |
| // InternalEssentialOCL.g:7808:2: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_40); |
| rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop67; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group__0" |
| // InternalEssentialOCL.g:7822:1: rule__SquareBracketedClauseCS__Group__0 : rule__SquareBracketedClauseCS__Group__0__Impl rule__SquareBracketedClauseCS__Group__1 ; |
| public final void rule__SquareBracketedClauseCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7826:1: ( rule__SquareBracketedClauseCS__Group__0__Impl rule__SquareBracketedClauseCS__Group__1 ) |
| // InternalEssentialOCL.g:7827:2: rule__SquareBracketedClauseCS__Group__0__Impl rule__SquareBracketedClauseCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__SquareBracketedClauseCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SquareBracketedClauseCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__Group__0" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group__0__Impl" |
| // InternalEssentialOCL.g:7834:1: rule__SquareBracketedClauseCS__Group__0__Impl : ( '[' ) ; |
| public final void rule__SquareBracketedClauseCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7838:1: ( ( '[' ) ) |
| // InternalEssentialOCL.g:7839:1: ( '[' ) |
| { |
| // InternalEssentialOCL.g:7839:1: ( '[' ) |
| // InternalEssentialOCL.g:7840:1: '[' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSquareBracketedClauseCSAccess().getLeftSquareBracketKeyword_0()); |
| } |
| match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSquareBracketedClauseCSAccess().getLeftSquareBracketKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group__1" |
| // InternalEssentialOCL.g:7853:1: rule__SquareBracketedClauseCS__Group__1 : rule__SquareBracketedClauseCS__Group__1__Impl rule__SquareBracketedClauseCS__Group__2 ; |
| public final void rule__SquareBracketedClauseCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7857:1: ( rule__SquareBracketedClauseCS__Group__1__Impl rule__SquareBracketedClauseCS__Group__2 ) |
| // InternalEssentialOCL.g:7858:2: rule__SquareBracketedClauseCS__Group__1__Impl rule__SquareBracketedClauseCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_41); |
| rule__SquareBracketedClauseCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SquareBracketedClauseCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__Group__1" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group__1__Impl" |
| // InternalEssentialOCL.g:7865:1: rule__SquareBracketedClauseCS__Group__1__Impl : ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) ) ; |
| public final void rule__SquareBracketedClauseCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7869:1: ( ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) ) ) |
| // InternalEssentialOCL.g:7870:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) ) |
| { |
| // InternalEssentialOCL.g:7870:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) ) |
| // InternalEssentialOCL.g:7871:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_1()); |
| } |
| // InternalEssentialOCL.g:7872:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) |
| // InternalEssentialOCL.g:7872:2: rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SquareBracketedClauseCS__OwnedTermsAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group__2" |
| // InternalEssentialOCL.g:7882:1: rule__SquareBracketedClauseCS__Group__2 : rule__SquareBracketedClauseCS__Group__2__Impl rule__SquareBracketedClauseCS__Group__3 ; |
| public final void rule__SquareBracketedClauseCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7886:1: ( rule__SquareBracketedClauseCS__Group__2__Impl rule__SquareBracketedClauseCS__Group__3 ) |
| // InternalEssentialOCL.g:7887:2: rule__SquareBracketedClauseCS__Group__2__Impl rule__SquareBracketedClauseCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_41); |
| rule__SquareBracketedClauseCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SquareBracketedClauseCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__Group__2" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group__2__Impl" |
| // InternalEssentialOCL.g:7894:1: rule__SquareBracketedClauseCS__Group__2__Impl : ( ( rule__SquareBracketedClauseCS__Group_2__0 )* ) ; |
| public final void rule__SquareBracketedClauseCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7898:1: ( ( ( rule__SquareBracketedClauseCS__Group_2__0 )* ) ) |
| // InternalEssentialOCL.g:7899:1: ( ( rule__SquareBracketedClauseCS__Group_2__0 )* ) |
| { |
| // InternalEssentialOCL.g:7899:1: ( ( rule__SquareBracketedClauseCS__Group_2__0 )* ) |
| // InternalEssentialOCL.g:7900:1: ( rule__SquareBracketedClauseCS__Group_2__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSquareBracketedClauseCSAccess().getGroup_2()); |
| } |
| // InternalEssentialOCL.g:7901:1: ( rule__SquareBracketedClauseCS__Group_2__0 )* |
| loop68: |
| do { |
| int alt68=2; |
| int LA68_0 = input.LA(1); |
| |
| if ( (LA68_0==61) ) { |
| alt68=1; |
| } |
| |
| |
| switch (alt68) { |
| case 1 : |
| // InternalEssentialOCL.g:7901:2: rule__SquareBracketedClauseCS__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_11); |
| rule__SquareBracketedClauseCS__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop68; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSquareBracketedClauseCSAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group__3" |
| // InternalEssentialOCL.g:7911:1: rule__SquareBracketedClauseCS__Group__3 : rule__SquareBracketedClauseCS__Group__3__Impl ; |
| public final void rule__SquareBracketedClauseCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7915:1: ( rule__SquareBracketedClauseCS__Group__3__Impl ) |
| // InternalEssentialOCL.g:7916:2: rule__SquareBracketedClauseCS__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SquareBracketedClauseCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__Group__3" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group__3__Impl" |
| // InternalEssentialOCL.g:7922:1: rule__SquareBracketedClauseCS__Group__3__Impl : ( ']' ) ; |
| public final void rule__SquareBracketedClauseCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7926:1: ( ( ']' ) ) |
| // InternalEssentialOCL.g:7927:1: ( ']' ) |
| { |
| // InternalEssentialOCL.g:7927:1: ( ']' ) |
| // InternalEssentialOCL.g:7928:1: ']' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSquareBracketedClauseCSAccess().getRightSquareBracketKeyword_3()); |
| } |
| match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSquareBracketedClauseCSAccess().getRightSquareBracketKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__0" |
| // InternalEssentialOCL.g:7949:1: rule__SquareBracketedClauseCS__Group_2__0 : rule__SquareBracketedClauseCS__Group_2__0__Impl rule__SquareBracketedClauseCS__Group_2__1 ; |
| public final void rule__SquareBracketedClauseCS__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7953:1: ( rule__SquareBracketedClauseCS__Group_2__0__Impl rule__SquareBracketedClauseCS__Group_2__1 ) |
| // InternalEssentialOCL.g:7954:2: rule__SquareBracketedClauseCS__Group_2__0__Impl rule__SquareBracketedClauseCS__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__SquareBracketedClauseCS__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SquareBracketedClauseCS__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__Group_2__0" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__0__Impl" |
| // InternalEssentialOCL.g:7961:1: rule__SquareBracketedClauseCS__Group_2__0__Impl : ( ',' ) ; |
| public final void rule__SquareBracketedClauseCS__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7965:1: ( ( ',' ) ) |
| // InternalEssentialOCL.g:7966:1: ( ',' ) |
| { |
| // InternalEssentialOCL.g:7966:1: ( ',' ) |
| // InternalEssentialOCL.g:7967:1: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSquareBracketedClauseCSAccess().getCommaKeyword_2_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSquareBracketedClauseCSAccess().getCommaKeyword_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__1" |
| // InternalEssentialOCL.g:7980:1: rule__SquareBracketedClauseCS__Group_2__1 : rule__SquareBracketedClauseCS__Group_2__1__Impl ; |
| public final void rule__SquareBracketedClauseCS__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7984:1: ( rule__SquareBracketedClauseCS__Group_2__1__Impl ) |
| // InternalEssentialOCL.g:7985:2: rule__SquareBracketedClauseCS__Group_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SquareBracketedClauseCS__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__SquareBracketedClauseCS__Group_2__1" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__1__Impl" |
| // InternalEssentialOCL.g:7991:1: rule__SquareBracketedClauseCS__Group_2__1__Impl : ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) ) ; |
| public final void rule__SquareBracketedClauseCS__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:7995:1: ( ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) ) ) |
| // InternalEssentialOCL.g:7996:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:7996:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) ) |
| // InternalEssentialOCL.g:7997:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_2_1()); |
| } |
| // InternalEssentialOCL.g:7998:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) |
| // InternalEssentialOCL.g:7998:2: rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0__0" |
| // InternalEssentialOCL.g:8012:1: rule__NavigatingArgCS__Group_0__0 : rule__NavigatingArgCS__Group_0__0__Impl rule__NavigatingArgCS__Group_0__1 ; |
| public final void rule__NavigatingArgCS__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8016:1: ( rule__NavigatingArgCS__Group_0__0__Impl rule__NavigatingArgCS__Group_0__1 ) |
| // InternalEssentialOCL.g:8017:2: rule__NavigatingArgCS__Group_0__0__Impl rule__NavigatingArgCS__Group_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_42); |
| rule__NavigatingArgCS__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0__0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0__0__Impl" |
| // InternalEssentialOCL.g:8024:1: rule__NavigatingArgCS__Group_0__0__Impl : ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8028:1: ( ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) ) ) |
| // InternalEssentialOCL.g:8029:1: ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) ) |
| { |
| // InternalEssentialOCL.g:8029:1: ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) ) |
| // InternalEssentialOCL.g:8030:1: ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionAssignment_0_0()); |
| } |
| // InternalEssentialOCL.g:8031:1: ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) |
| // InternalEssentialOCL.g:8031:2: rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionAssignment_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0__1" |
| // InternalEssentialOCL.g:8041:1: rule__NavigatingArgCS__Group_0__1 : rule__NavigatingArgCS__Group_0__1__Impl ; |
| public final void rule__NavigatingArgCS__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8045:1: ( rule__NavigatingArgCS__Group_0__1__Impl ) |
| // InternalEssentialOCL.g:8046:2: rule__NavigatingArgCS__Group_0__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__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__NavigatingArgCS__Group_0__1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0__1__Impl" |
| // InternalEssentialOCL.g:8052:1: rule__NavigatingArgCS__Group_0__1__Impl : ( ( rule__NavigatingArgCS__Alternatives_0_1 )? ) ; |
| public final void rule__NavigatingArgCS__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8056:1: ( ( ( rule__NavigatingArgCS__Alternatives_0_1 )? ) ) |
| // InternalEssentialOCL.g:8057:1: ( ( rule__NavigatingArgCS__Alternatives_0_1 )? ) |
| { |
| // InternalEssentialOCL.g:8057:1: ( ( rule__NavigatingArgCS__Alternatives_0_1 )? ) |
| // InternalEssentialOCL.g:8058:1: ( rule__NavigatingArgCS__Alternatives_0_1 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1()); |
| } |
| // InternalEssentialOCL.g:8059:1: ( rule__NavigatingArgCS__Alternatives_0_1 )? |
| int alt69=2; |
| int LA69_0 = input.LA(1); |
| |
| if ( ((LA69_0>=55 && LA69_0<=56)||LA69_0==62||LA69_0==73) ) { |
| alt69=1; |
| } |
| switch (alt69) { |
| case 1 : |
| // InternalEssentialOCL.g:8059:2: rule__NavigatingArgCS__Alternatives_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Alternatives_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__0" |
| // InternalEssentialOCL.g:8073:1: rule__NavigatingArgCS__Group_0_1_0__0 : rule__NavigatingArgCS__Group_0_1_0__0__Impl rule__NavigatingArgCS__Group_0_1_0__1 ; |
| public final void rule__NavigatingArgCS__Group_0_1_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8077:1: ( rule__NavigatingArgCS__Group_0_1_0__0__Impl rule__NavigatingArgCS__Group_0_1_0__1 ) |
| // InternalEssentialOCL.g:8078:2: rule__NavigatingArgCS__Group_0_1_0__0__Impl rule__NavigatingArgCS__Group_0_1_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__NavigatingArgCS__Group_0_1_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__0__Impl" |
| // InternalEssentialOCL.g:8085:1: rule__NavigatingArgCS__Group_0_1_0__0__Impl : ( ( rule__NavigatingArgCS__Alternatives_0_1_0_0 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8089:1: ( ( ( rule__NavigatingArgCS__Alternatives_0_1_0_0 ) ) ) |
| // InternalEssentialOCL.g:8090:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_0_0 ) ) |
| { |
| // InternalEssentialOCL.g:8090:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_0_0 ) ) |
| // InternalEssentialOCL.g:8091:1: ( rule__NavigatingArgCS__Alternatives_0_1_0_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_0_0()); |
| } |
| // InternalEssentialOCL.g:8092:1: ( rule__NavigatingArgCS__Alternatives_0_1_0_0 ) |
| // InternalEssentialOCL.g:8092:2: rule__NavigatingArgCS__Alternatives_0_1_0_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Alternatives_0_1_0_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__1" |
| // InternalEssentialOCL.g:8102:1: rule__NavigatingArgCS__Group_0_1_0__1 : rule__NavigatingArgCS__Group_0_1_0__1__Impl rule__NavigatingArgCS__Group_0_1_0__2 ; |
| public final void rule__NavigatingArgCS__Group_0_1_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8106:1: ( rule__NavigatingArgCS__Group_0_1_0__1__Impl rule__NavigatingArgCS__Group_0_1_0__2 ) |
| // InternalEssentialOCL.g:8107:2: rule__NavigatingArgCS__Group_0_1_0__1__Impl rule__NavigatingArgCS__Group_0_1_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__NavigatingArgCS__Group_0_1_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__1__Impl" |
| // InternalEssentialOCL.g:8114:1: rule__NavigatingArgCS__Group_0_1_0__1__Impl : ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8118:1: ( ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) ) ) |
| // InternalEssentialOCL.g:8119:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) ) |
| { |
| // InternalEssentialOCL.g:8119:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) ) |
| // InternalEssentialOCL.g:8120:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_0_1()); |
| } |
| // InternalEssentialOCL.g:8121:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) |
| // InternalEssentialOCL.g:8121:2: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__2" |
| // InternalEssentialOCL.g:8131:1: rule__NavigatingArgCS__Group_0_1_0__2 : rule__NavigatingArgCS__Group_0_1_0__2__Impl ; |
| public final void rule__NavigatingArgCS__Group_0_1_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8135:1: ( rule__NavigatingArgCS__Group_0_1_0__2__Impl ) |
| // InternalEssentialOCL.g:8136:2: rule__NavigatingArgCS__Group_0_1_0__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__2" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__2__Impl" |
| // InternalEssentialOCL.g:8142:1: rule__NavigatingArgCS__Group_0_1_0__2__Impl : ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8146:1: ( ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? ) ) |
| // InternalEssentialOCL.g:8147:1: ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:8147:1: ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? ) |
| // InternalEssentialOCL.g:8148:1: ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0_2()); |
| } |
| // InternalEssentialOCL.g:8149:1: ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? |
| int alt70=2; |
| int LA70_0 = input.LA(1); |
| |
| if ( (LA70_0==26) ) { |
| alt70=1; |
| } |
| switch (alt70) { |
| case 1 : |
| // InternalEssentialOCL.g:8149:2: rule__NavigatingArgCS__Group_0_1_0_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_0_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__0" |
| // InternalEssentialOCL.g:8165:1: rule__NavigatingArgCS__Group_0_1_0_2__0 : rule__NavigatingArgCS__Group_0_1_0_2__0__Impl rule__NavigatingArgCS__Group_0_1_0_2__1 ; |
| public final void rule__NavigatingArgCS__Group_0_1_0_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8169:1: ( rule__NavigatingArgCS__Group_0_1_0_2__0__Impl rule__NavigatingArgCS__Group_0_1_0_2__1 ) |
| // InternalEssentialOCL.g:8170:2: rule__NavigatingArgCS__Group_0_1_0_2__0__Impl rule__NavigatingArgCS__Group_0_1_0_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NavigatingArgCS__Group_0_1_0_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_0_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__0__Impl" |
| // InternalEssentialOCL.g:8177:1: rule__NavigatingArgCS__Group_0_1_0_2__0__Impl : ( '=' ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_0_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8181:1: ( ( '=' ) ) |
| // InternalEssentialOCL.g:8182:1: ( '=' ) |
| { |
| // InternalEssentialOCL.g:8182:1: ( '=' ) |
| // InternalEssentialOCL.g:8183:1: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_0_2_0()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_0_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__1" |
| // InternalEssentialOCL.g:8196:1: rule__NavigatingArgCS__Group_0_1_0_2__1 : rule__NavigatingArgCS__Group_0_1_0_2__1__Impl ; |
| public final void rule__NavigatingArgCS__Group_0_1_0_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8200:1: ( rule__NavigatingArgCS__Group_0_1_0_2__1__Impl ) |
| // InternalEssentialOCL.g:8201:2: rule__NavigatingArgCS__Group_0_1_0_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_0_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__1__Impl" |
| // InternalEssentialOCL.g:8207:1: rule__NavigatingArgCS__Group_0_1_0_2__1__Impl : ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_0_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8211:1: ( ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) ) ) |
| // InternalEssentialOCL.g:8212:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:8212:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) ) |
| // InternalEssentialOCL.g:8213:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_0_2_1()); |
| } |
| // InternalEssentialOCL.g:8214:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) |
| // InternalEssentialOCL.g:8214:2: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_0_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__0" |
| // InternalEssentialOCL.g:8228:1: rule__NavigatingArgCS__Group_0_1_1__0 : rule__NavigatingArgCS__Group_0_1_1__0__Impl rule__NavigatingArgCS__Group_0_1_1__1 ; |
| public final void rule__NavigatingArgCS__Group_0_1_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8232:1: ( rule__NavigatingArgCS__Group_0_1_1__0__Impl rule__NavigatingArgCS__Group_0_1_1__1 ) |
| // InternalEssentialOCL.g:8233:2: rule__NavigatingArgCS__Group_0_1_1__0__Impl rule__NavigatingArgCS__Group_0_1_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__NavigatingArgCS__Group_0_1_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__0__Impl" |
| // InternalEssentialOCL.g:8240:1: rule__NavigatingArgCS__Group_0_1_1__0__Impl : ( ':' ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8244:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:8245:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:8245:1: ( ':' ) |
| // InternalEssentialOCL.g:8246:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_1_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__1" |
| // InternalEssentialOCL.g:8259:1: rule__NavigatingArgCS__Group_0_1_1__1 : rule__NavigatingArgCS__Group_0_1_1__1__Impl rule__NavigatingArgCS__Group_0_1_1__2 ; |
| public final void rule__NavigatingArgCS__Group_0_1_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8263:1: ( rule__NavigatingArgCS__Group_0_1_1__1__Impl rule__NavigatingArgCS__Group_0_1_1__2 ) |
| // InternalEssentialOCL.g:8264:2: rule__NavigatingArgCS__Group_0_1_1__1__Impl rule__NavigatingArgCS__Group_0_1_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_43); |
| rule__NavigatingArgCS__Group_0_1_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__1__Impl" |
| // InternalEssentialOCL.g:8271:1: rule__NavigatingArgCS__Group_0_1_1__1__Impl : ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8275:1: ( ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) ) ) |
| // InternalEssentialOCL.g:8276:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:8276:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) ) |
| // InternalEssentialOCL.g:8277:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_1_1()); |
| } |
| // InternalEssentialOCL.g:8278:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) |
| // InternalEssentialOCL.g:8278:2: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__2" |
| // InternalEssentialOCL.g:8288:1: rule__NavigatingArgCS__Group_0_1_1__2 : rule__NavigatingArgCS__Group_0_1_1__2__Impl rule__NavigatingArgCS__Group_0_1_1__3 ; |
| public final void rule__NavigatingArgCS__Group_0_1_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8292:1: ( rule__NavigatingArgCS__Group_0_1_1__2__Impl rule__NavigatingArgCS__Group_0_1_1__3 ) |
| // InternalEssentialOCL.g:8293:2: rule__NavigatingArgCS__Group_0_1_1__2__Impl rule__NavigatingArgCS__Group_0_1_1__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_43); |
| rule__NavigatingArgCS__Group_0_1_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__2" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__2__Impl" |
| // InternalEssentialOCL.g:8300:1: rule__NavigatingArgCS__Group_0_1_1__2__Impl : ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8304:1: ( ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? ) ) |
| // InternalEssentialOCL.g:8305:1: ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:8305:1: ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? ) |
| // InternalEssentialOCL.g:8306:1: ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_2()); |
| } |
| // InternalEssentialOCL.g:8307:1: ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? |
| int alt71=2; |
| int LA71_0 = input.LA(1); |
| |
| if ( ((LA71_0>=55 && LA71_0<=56)) ) { |
| alt71=1; |
| } |
| switch (alt71) { |
| case 1 : |
| // InternalEssentialOCL.g:8307:2: rule__NavigatingArgCS__Group_0_1_1_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_1_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__3" |
| // InternalEssentialOCL.g:8317:1: rule__NavigatingArgCS__Group_0_1_1__3 : rule__NavigatingArgCS__Group_0_1_1__3__Impl ; |
| public final void rule__NavigatingArgCS__Group_0_1_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8321:1: ( rule__NavigatingArgCS__Group_0_1_1__3__Impl ) |
| // InternalEssentialOCL.g:8322:2: rule__NavigatingArgCS__Group_0_1_1__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_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__NavigatingArgCS__Group_0_1_1__3" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__3__Impl" |
| // InternalEssentialOCL.g:8328:1: rule__NavigatingArgCS__Group_0_1_1__3__Impl : ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8332:1: ( ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? ) ) |
| // InternalEssentialOCL.g:8333:1: ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? ) |
| { |
| // InternalEssentialOCL.g:8333:1: ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? ) |
| // InternalEssentialOCL.g:8334:1: ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_3()); |
| } |
| // InternalEssentialOCL.g:8335:1: ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? |
| int alt72=2; |
| int LA72_0 = input.LA(1); |
| |
| if ( (LA72_0==26) ) { |
| alt72=1; |
| } |
| switch (alt72) { |
| case 1 : |
| // InternalEssentialOCL.g:8335:2: rule__NavigatingArgCS__Group_0_1_1_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_1_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__0" |
| // InternalEssentialOCL.g:8353:1: rule__NavigatingArgCS__Group_0_1_1_2__0 : rule__NavigatingArgCS__Group_0_1_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_1_2__1 ; |
| public final void rule__NavigatingArgCS__Group_0_1_1_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8357:1: ( rule__NavigatingArgCS__Group_0_1_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_1_2__1 ) |
| // InternalEssentialOCL.g:8358:2: rule__NavigatingArgCS__Group_0_1_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_1_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__NavigatingArgCS__Group_0_1_1_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_1_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__0__Impl" |
| // InternalEssentialOCL.g:8365:1: rule__NavigatingArgCS__Group_0_1_1_2__0__Impl : ( ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_1_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8369:1: ( ( ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 ) ) ) |
| // InternalEssentialOCL.g:8370:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 ) ) |
| { |
| // InternalEssentialOCL.g:8370:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 ) ) |
| // InternalEssentialOCL.g:8371:1: ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_1_2_0()); |
| } |
| // InternalEssentialOCL.g:8372:1: ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 ) |
| // InternalEssentialOCL.g:8372:2: rule__NavigatingArgCS__Alternatives_0_1_1_2_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Alternatives_0_1_1_2_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__1" |
| // InternalEssentialOCL.g:8382:1: rule__NavigatingArgCS__Group_0_1_1_2__1 : rule__NavigatingArgCS__Group_0_1_1_2__1__Impl ; |
| public final void rule__NavigatingArgCS__Group_0_1_1_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8386:1: ( rule__NavigatingArgCS__Group_0_1_1_2__1__Impl ) |
| // InternalEssentialOCL.g:8387:2: rule__NavigatingArgCS__Group_0_1_1_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_1_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__1__Impl" |
| // InternalEssentialOCL.g:8393:1: rule__NavigatingArgCS__Group_0_1_1_2__1__Impl : ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_1_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8397:1: ( ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) ) ) |
| // InternalEssentialOCL.g:8398:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:8398:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) ) |
| // InternalEssentialOCL.g:8399:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_1_2_1()); |
| } |
| // InternalEssentialOCL.g:8400:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) |
| // InternalEssentialOCL.g:8400:2: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_1_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__0" |
| // InternalEssentialOCL.g:8414:1: rule__NavigatingArgCS__Group_0_1_1_3__0 : rule__NavigatingArgCS__Group_0_1_1_3__0__Impl rule__NavigatingArgCS__Group_0_1_1_3__1 ; |
| public final void rule__NavigatingArgCS__Group_0_1_1_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8418:1: ( rule__NavigatingArgCS__Group_0_1_1_3__0__Impl rule__NavigatingArgCS__Group_0_1_1_3__1 ) |
| // InternalEssentialOCL.g:8419:2: rule__NavigatingArgCS__Group_0_1_1_3__0__Impl rule__NavigatingArgCS__Group_0_1_1_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NavigatingArgCS__Group_0_1_1_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_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__NavigatingArgCS__Group_0_1_1_3__0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__0__Impl" |
| // InternalEssentialOCL.g:8426:1: rule__NavigatingArgCS__Group_0_1_1_3__0__Impl : ( '=' ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_1_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8430:1: ( ( '=' ) ) |
| // InternalEssentialOCL.g:8431:1: ( '=' ) |
| { |
| // InternalEssentialOCL.g:8431:1: ( '=' ) |
| // InternalEssentialOCL.g:8432:1: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_1_3_0()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_1_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__1" |
| // InternalEssentialOCL.g:8445:1: rule__NavigatingArgCS__Group_0_1_1_3__1 : rule__NavigatingArgCS__Group_0_1_1_3__1__Impl ; |
| public final void rule__NavigatingArgCS__Group_0_1_1_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8449:1: ( rule__NavigatingArgCS__Group_0_1_1_3__1__Impl ) |
| // InternalEssentialOCL.g:8450:2: rule__NavigatingArgCS__Group_0_1_1_3__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_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__NavigatingArgCS__Group_0_1_1_3__1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__1__Impl" |
| // InternalEssentialOCL.g:8456:1: rule__NavigatingArgCS__Group_0_1_1_3__1__Impl : ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_1_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8460:1: ( ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) ) ) |
| // InternalEssentialOCL.g:8461:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) ) |
| { |
| // InternalEssentialOCL.g:8461:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) ) |
| // InternalEssentialOCL.g:8462:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_1_3_1()); |
| } |
| // InternalEssentialOCL.g:8463:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) |
| // InternalEssentialOCL.g:8463:2: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_1_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__0" |
| // InternalEssentialOCL.g:8477:1: rule__NavigatingArgCS__Group_0_1_2__0 : rule__NavigatingArgCS__Group_0_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_2__1 ; |
| public final void rule__NavigatingArgCS__Group_0_1_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8481:1: ( rule__NavigatingArgCS__Group_0_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_2__1 ) |
| // InternalEssentialOCL.g:8482:2: rule__NavigatingArgCS__Group_0_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_42); |
| rule__NavigatingArgCS__Group_0_1_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__0__Impl" |
| // InternalEssentialOCL.g:8489:1: rule__NavigatingArgCS__Group_0_1_2__0__Impl : ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8493:1: ( ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? ) ) |
| // InternalEssentialOCL.g:8494:1: ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? ) |
| { |
| // InternalEssentialOCL.g:8494:1: ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? ) |
| // InternalEssentialOCL.g:8495:1: ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_0()); |
| } |
| // InternalEssentialOCL.g:8496:1: ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? |
| int alt73=2; |
| int LA73_0 = input.LA(1); |
| |
| if ( (LA73_0==62) ) { |
| alt73=1; |
| } |
| switch (alt73) { |
| case 1 : |
| // InternalEssentialOCL.g:8496:2: rule__NavigatingArgCS__Group_0_1_2_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_2_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__1" |
| // InternalEssentialOCL.g:8506:1: rule__NavigatingArgCS__Group_0_1_2__1 : rule__NavigatingArgCS__Group_0_1_2__1__Impl rule__NavigatingArgCS__Group_0_1_2__2 ; |
| public final void rule__NavigatingArgCS__Group_0_1_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8510:1: ( rule__NavigatingArgCS__Group_0_1_2__1__Impl rule__NavigatingArgCS__Group_0_1_2__2 ) |
| // InternalEssentialOCL.g:8511:2: rule__NavigatingArgCS__Group_0_1_2__1__Impl rule__NavigatingArgCS__Group_0_1_2__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_42); |
| rule__NavigatingArgCS__Group_0_1_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_2__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__1__Impl" |
| // InternalEssentialOCL.g:8518:1: rule__NavigatingArgCS__Group_0_1_2__1__Impl : ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8522:1: ( ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? ) ) |
| // InternalEssentialOCL.g:8523:1: ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:8523:1: ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? ) |
| // InternalEssentialOCL.g:8524:1: ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_1()); |
| } |
| // InternalEssentialOCL.g:8525:1: ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? |
| int alt74=2; |
| int LA74_0 = input.LA(1); |
| |
| if ( ((LA74_0>=55 && LA74_0<=56)) ) { |
| alt74=1; |
| } |
| switch (alt74) { |
| case 1 : |
| // InternalEssentialOCL.g:8525:2: rule__NavigatingArgCS__Group_0_1_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__2" |
| // InternalEssentialOCL.g:8535:1: rule__NavigatingArgCS__Group_0_1_2__2 : rule__NavigatingArgCS__Group_0_1_2__2__Impl rule__NavigatingArgCS__Group_0_1_2__3 ; |
| public final void rule__NavigatingArgCS__Group_0_1_2__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8539:1: ( rule__NavigatingArgCS__Group_0_1_2__2__Impl rule__NavigatingArgCS__Group_0_1_2__3 ) |
| // InternalEssentialOCL.g:8540:2: rule__NavigatingArgCS__Group_0_1_2__2__Impl rule__NavigatingArgCS__Group_0_1_2__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NavigatingArgCS__Group_0_1_2__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_2__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__2" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__2__Impl" |
| // InternalEssentialOCL.g:8547:1: rule__NavigatingArgCS__Group_0_1_2__2__Impl : ( 'in' ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_2__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8551:1: ( ( 'in' ) ) |
| // InternalEssentialOCL.g:8552:1: ( 'in' ) |
| { |
| // InternalEssentialOCL.g:8552:1: ( 'in' ) |
| // InternalEssentialOCL.g:8553:1: 'in' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getInKeyword_0_1_2_2()); |
| } |
| match(input,73,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getInKeyword_0_1_2_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__2__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__3" |
| // InternalEssentialOCL.g:8566:1: rule__NavigatingArgCS__Group_0_1_2__3 : rule__NavigatingArgCS__Group_0_1_2__3__Impl ; |
| public final void rule__NavigatingArgCS__Group_0_1_2__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8570:1: ( rule__NavigatingArgCS__Group_0_1_2__3__Impl ) |
| // InternalEssentialOCL.g:8571:2: rule__NavigatingArgCS__Group_0_1_2__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_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__NavigatingArgCS__Group_0_1_2__3" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__3__Impl" |
| // InternalEssentialOCL.g:8577:1: rule__NavigatingArgCS__Group_0_1_2__3__Impl : ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_2__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8581:1: ( ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) ) ) |
| // InternalEssentialOCL.g:8582:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) ) |
| { |
| // InternalEssentialOCL.g:8582:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) ) |
| // InternalEssentialOCL.g:8583:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_2_3()); |
| } |
| // InternalEssentialOCL.g:8584:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) |
| // InternalEssentialOCL.g:8584:2: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_2_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__3__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__0" |
| // InternalEssentialOCL.g:8602:1: rule__NavigatingArgCS__Group_0_1_2_0__0 : rule__NavigatingArgCS__Group_0_1_2_0__0__Impl rule__NavigatingArgCS__Group_0_1_2_0__1 ; |
| public final void rule__NavigatingArgCS__Group_0_1_2_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8606:1: ( rule__NavigatingArgCS__Group_0_1_2_0__0__Impl rule__NavigatingArgCS__Group_0_1_2_0__1 ) |
| // InternalEssentialOCL.g:8607:2: rule__NavigatingArgCS__Group_0_1_2_0__0__Impl rule__NavigatingArgCS__Group_0_1_2_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__NavigatingArgCS__Group_0_1_2_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_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__NavigatingArgCS__Group_0_1_2_0__0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__0__Impl" |
| // InternalEssentialOCL.g:8614:1: rule__NavigatingArgCS__Group_0_1_2_0__0__Impl : ( ':' ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_2_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8618:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:8619:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:8619:1: ( ':' ) |
| // InternalEssentialOCL.g:8620:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_2_0_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__1" |
| // InternalEssentialOCL.g:8633:1: rule__NavigatingArgCS__Group_0_1_2_0__1 : rule__NavigatingArgCS__Group_0_1_2_0__1__Impl ; |
| public final void rule__NavigatingArgCS__Group_0_1_2_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8637:1: ( rule__NavigatingArgCS__Group_0_1_2_0__1__Impl ) |
| // InternalEssentialOCL.g:8638:2: rule__NavigatingArgCS__Group_0_1_2_0__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_2_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_0__1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__1__Impl" |
| // InternalEssentialOCL.g:8644:1: rule__NavigatingArgCS__Group_0_1_2_0__1__Impl : ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_2_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8648:1: ( ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) ) ) |
| // InternalEssentialOCL.g:8649:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) ) |
| { |
| // InternalEssentialOCL.g:8649:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) ) |
| // InternalEssentialOCL.g:8650:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_2_0_1()); |
| } |
| // InternalEssentialOCL.g:8651:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) |
| // InternalEssentialOCL.g:8651:2: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_2_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__0" |
| // InternalEssentialOCL.g:8665:1: rule__NavigatingArgCS__Group_0_1_2_1__0 : rule__NavigatingArgCS__Group_0_1_2_1__0__Impl rule__NavigatingArgCS__Group_0_1_2_1__1 ; |
| public final void rule__NavigatingArgCS__Group_0_1_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8669:1: ( rule__NavigatingArgCS__Group_0_1_2_1__0__Impl rule__NavigatingArgCS__Group_0_1_2_1__1 ) |
| // InternalEssentialOCL.g:8670:2: rule__NavigatingArgCS__Group_0_1_2_1__0__Impl rule__NavigatingArgCS__Group_0_1_2_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__NavigatingArgCS__Group_0_1_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_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__NavigatingArgCS__Group_0_1_2_1__0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__0__Impl" |
| // InternalEssentialOCL.g:8677:1: rule__NavigatingArgCS__Group_0_1_2_1__0__Impl : ( ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8681:1: ( ( ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 ) ) ) |
| // InternalEssentialOCL.g:8682:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 ) ) |
| { |
| // InternalEssentialOCL.g:8682:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 ) ) |
| // InternalEssentialOCL.g:8683:1: ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_2_1_0()); |
| } |
| // InternalEssentialOCL.g:8684:1: ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 ) |
| // InternalEssentialOCL.g:8684:2: rule__NavigatingArgCS__Alternatives_0_1_2_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Alternatives_0_1_2_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__1" |
| // InternalEssentialOCL.g:8694:1: rule__NavigatingArgCS__Group_0_1_2_1__1 : rule__NavigatingArgCS__Group_0_1_2_1__1__Impl ; |
| public final void rule__NavigatingArgCS__Group_0_1_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8698:1: ( rule__NavigatingArgCS__Group_0_1_2_1__1__Impl ) |
| // InternalEssentialOCL.g:8699:2: rule__NavigatingArgCS__Group_0_1_2_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_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__NavigatingArgCS__Group_0_1_2_1__1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__1__Impl" |
| // InternalEssentialOCL.g:8705:1: rule__NavigatingArgCS__Group_0_1_2_1__1__Impl : ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) ) ; |
| public final void rule__NavigatingArgCS__Group_0_1_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8709:1: ( ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) ) ) |
| // InternalEssentialOCL.g:8710:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:8710:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) ) |
| // InternalEssentialOCL.g:8711:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_2_1_1()); |
| } |
| // InternalEssentialOCL.g:8712:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) |
| // InternalEssentialOCL.g:8712:2: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_1__0" |
| // InternalEssentialOCL.g:8726:1: rule__NavigatingArgCS__Group_1__0 : rule__NavigatingArgCS__Group_1__0__Impl rule__NavigatingArgCS__Group_1__1 ; |
| public final void rule__NavigatingArgCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8730:1: ( rule__NavigatingArgCS__Group_1__0__Impl rule__NavigatingArgCS__Group_1__1 ) |
| // InternalEssentialOCL.g:8731:2: rule__NavigatingArgCS__Group_1__0__Impl rule__NavigatingArgCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__NavigatingArgCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:8738:1: rule__NavigatingArgCS__Group_1__0__Impl : ( ':' ) ; |
| public final void rule__NavigatingArgCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8742:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:8743:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:8743:1: ( ':' ) |
| // InternalEssentialOCL.g:8744:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_1_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_1__1" |
| // InternalEssentialOCL.g:8757:1: rule__NavigatingArgCS__Group_1__1 : rule__NavigatingArgCS__Group_1__1__Impl ; |
| public final void rule__NavigatingArgCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8761:1: ( rule__NavigatingArgCS__Group_1__1__Impl ) |
| // InternalEssentialOCL.g:8762:2: rule__NavigatingArgCS__Group_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__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__NavigatingArgCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:8768:1: rule__NavigatingArgCS__Group_1__1__Impl : ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) ) ; |
| public final void rule__NavigatingArgCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8772:1: ( ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) ) ) |
| // InternalEssentialOCL.g:8773:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:8773:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) ) |
| // InternalEssentialOCL.g:8774:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_1_1()); |
| } |
| // InternalEssentialOCL.g:8775:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) |
| // InternalEssentialOCL.g:8775:2: rule__NavigatingArgCS__OwnedTypeAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__OwnedTypeAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group__0" |
| // InternalEssentialOCL.g:8789:1: rule__NavigatingBarArgCS__Group__0 : rule__NavigatingBarArgCS__Group__0__Impl rule__NavigatingBarArgCS__Group__1 ; |
| public final void rule__NavigatingBarArgCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8793:1: ( rule__NavigatingBarArgCS__Group__0__Impl rule__NavigatingBarArgCS__Group__1 ) |
| // InternalEssentialOCL.g:8794:2: rule__NavigatingBarArgCS__Group__0__Impl rule__NavigatingBarArgCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NavigatingBarArgCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group__0" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group__0__Impl" |
| // InternalEssentialOCL.g:8801:1: rule__NavigatingBarArgCS__Group__0__Impl : ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) ) ; |
| public final void rule__NavigatingBarArgCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8805:1: ( ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:8806:1: ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:8806:1: ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) ) |
| // InternalEssentialOCL.g:8807:1: ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixAssignment_0()); |
| } |
| // InternalEssentialOCL.g:8808:1: ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) |
| // InternalEssentialOCL.g:8808:2: rule__NavigatingBarArgCS__PrefixAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__PrefixAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getPrefixAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group__1" |
| // InternalEssentialOCL.g:8818:1: rule__NavigatingBarArgCS__Group__1 : rule__NavigatingBarArgCS__Group__1__Impl rule__NavigatingBarArgCS__Group__2 ; |
| public final void rule__NavigatingBarArgCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8822:1: ( rule__NavigatingBarArgCS__Group__1__Impl rule__NavigatingBarArgCS__Group__2 ) |
| // InternalEssentialOCL.g:8823:2: rule__NavigatingBarArgCS__Group__1__Impl rule__NavigatingBarArgCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__NavigatingBarArgCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group__1" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group__1__Impl" |
| // InternalEssentialOCL.g:8830:1: rule__NavigatingBarArgCS__Group__1__Impl : ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) ) ; |
| public final void rule__NavigatingBarArgCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8834:1: ( ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) ) ) |
| // InternalEssentialOCL.g:8835:1: ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) ) |
| { |
| // InternalEssentialOCL.g:8835:1: ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) ) |
| // InternalEssentialOCL.g:8836:1: ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionAssignment_1()); |
| } |
| // InternalEssentialOCL.g:8837:1: ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) |
| // InternalEssentialOCL.g:8837:2: rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group__2" |
| // InternalEssentialOCL.g:8847:1: rule__NavigatingBarArgCS__Group__2 : rule__NavigatingBarArgCS__Group__2__Impl ; |
| public final void rule__NavigatingBarArgCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8851:1: ( rule__NavigatingBarArgCS__Group__2__Impl ) |
| // InternalEssentialOCL.g:8852:2: rule__NavigatingBarArgCS__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group__2" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group__2__Impl" |
| // InternalEssentialOCL.g:8858:1: rule__NavigatingBarArgCS__Group__2__Impl : ( ( rule__NavigatingBarArgCS__Group_2__0 )? ) ; |
| public final void rule__NavigatingBarArgCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8862:1: ( ( ( rule__NavigatingBarArgCS__Group_2__0 )? ) ) |
| // InternalEssentialOCL.g:8863:1: ( ( rule__NavigatingBarArgCS__Group_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:8863:1: ( ( rule__NavigatingBarArgCS__Group_2__0 )? ) |
| // InternalEssentialOCL.g:8864:1: ( rule__NavigatingBarArgCS__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2()); |
| } |
| // InternalEssentialOCL.g:8865:1: ( rule__NavigatingBarArgCS__Group_2__0 )? |
| int alt75=2; |
| int LA75_0 = input.LA(1); |
| |
| if ( (LA75_0==62) ) { |
| alt75=1; |
| } |
| switch (alt75) { |
| case 1 : |
| // InternalEssentialOCL.g:8865:2: rule__NavigatingBarArgCS__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group_2__0" |
| // InternalEssentialOCL.g:8881:1: rule__NavigatingBarArgCS__Group_2__0 : rule__NavigatingBarArgCS__Group_2__0__Impl rule__NavigatingBarArgCS__Group_2__1 ; |
| public final void rule__NavigatingBarArgCS__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8885:1: ( rule__NavigatingBarArgCS__Group_2__0__Impl rule__NavigatingBarArgCS__Group_2__1 ) |
| // InternalEssentialOCL.g:8886:2: rule__NavigatingBarArgCS__Group_2__0__Impl rule__NavigatingBarArgCS__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__NavigatingBarArgCS__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group_2__0" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group_2__0__Impl" |
| // InternalEssentialOCL.g:8893:1: rule__NavigatingBarArgCS__Group_2__0__Impl : ( ':' ) ; |
| public final void rule__NavigatingBarArgCS__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8897:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:8898:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:8898:1: ( ':' ) |
| // InternalEssentialOCL.g:8899:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getColonKeyword_2_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getColonKeyword_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group_2__1" |
| // InternalEssentialOCL.g:8912:1: rule__NavigatingBarArgCS__Group_2__1 : rule__NavigatingBarArgCS__Group_2__1__Impl rule__NavigatingBarArgCS__Group_2__2 ; |
| public final void rule__NavigatingBarArgCS__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8916:1: ( rule__NavigatingBarArgCS__Group_2__1__Impl rule__NavigatingBarArgCS__Group_2__2 ) |
| // InternalEssentialOCL.g:8917:2: rule__NavigatingBarArgCS__Group_2__1__Impl rule__NavigatingBarArgCS__Group_2__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__NavigatingBarArgCS__Group_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__Group_2__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group_2__1" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group_2__1__Impl" |
| // InternalEssentialOCL.g:8924:1: rule__NavigatingBarArgCS__Group_2__1__Impl : ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) ) ; |
| public final void rule__NavigatingBarArgCS__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8928:1: ( ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) ) ) |
| // InternalEssentialOCL.g:8929:1: ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:8929:1: ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) ) |
| // InternalEssentialOCL.g:8930:1: ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeAssignment_2_1()); |
| } |
| // InternalEssentialOCL.g:8931:1: ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) |
| // InternalEssentialOCL.g:8931:2: rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeAssignment_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group_2__2" |
| // InternalEssentialOCL.g:8941:1: rule__NavigatingBarArgCS__Group_2__2 : rule__NavigatingBarArgCS__Group_2__2__Impl ; |
| public final void rule__NavigatingBarArgCS__Group_2__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8945:1: ( rule__NavigatingBarArgCS__Group_2__2__Impl ) |
| // InternalEssentialOCL.g:8946:2: rule__NavigatingBarArgCS__Group_2__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__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__NavigatingBarArgCS__Group_2__2" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group_2__2__Impl" |
| // InternalEssentialOCL.g:8952:1: rule__NavigatingBarArgCS__Group_2__2__Impl : ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? ) ; |
| public final void rule__NavigatingBarArgCS__Group_2__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8956:1: ( ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? ) ) |
| // InternalEssentialOCL.g:8957:1: ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:8957:1: ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? ) |
| // InternalEssentialOCL.g:8958:1: ( rule__NavigatingBarArgCS__Group_2_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2_2()); |
| } |
| // InternalEssentialOCL.g:8959:1: ( rule__NavigatingBarArgCS__Group_2_2__0 )? |
| int alt76=2; |
| int LA76_0 = input.LA(1); |
| |
| if ( (LA76_0==26) ) { |
| alt76=1; |
| } |
| switch (alt76) { |
| case 1 : |
| // InternalEssentialOCL.g:8959:2: rule__NavigatingBarArgCS__Group_2_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__Group_2_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group_2__2__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__0" |
| // InternalEssentialOCL.g:8975:1: rule__NavigatingBarArgCS__Group_2_2__0 : rule__NavigatingBarArgCS__Group_2_2__0__Impl rule__NavigatingBarArgCS__Group_2_2__1 ; |
| public final void rule__NavigatingBarArgCS__Group_2_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8979:1: ( rule__NavigatingBarArgCS__Group_2_2__0__Impl rule__NavigatingBarArgCS__Group_2_2__1 ) |
| // InternalEssentialOCL.g:8980:2: rule__NavigatingBarArgCS__Group_2_2__0__Impl rule__NavigatingBarArgCS__Group_2_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NavigatingBarArgCS__Group_2_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__Group_2_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__0" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__0__Impl" |
| // InternalEssentialOCL.g:8987:1: rule__NavigatingBarArgCS__Group_2_2__0__Impl : ( '=' ) ; |
| public final void rule__NavigatingBarArgCS__Group_2_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:8991:1: ( ( '=' ) ) |
| // InternalEssentialOCL.g:8992:1: ( '=' ) |
| { |
| // InternalEssentialOCL.g:8992:1: ( '=' ) |
| // InternalEssentialOCL.g:8993:1: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getEqualsSignKeyword_2_2_0()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getEqualsSignKeyword_2_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__1" |
| // InternalEssentialOCL.g:9006:1: rule__NavigatingBarArgCS__Group_2_2__1 : rule__NavigatingBarArgCS__Group_2_2__1__Impl ; |
| public final void rule__NavigatingBarArgCS__Group_2_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9010:1: ( rule__NavigatingBarArgCS__Group_2_2__1__Impl ) |
| // InternalEssentialOCL.g:9011:2: rule__NavigatingBarArgCS__Group_2_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__Group_2_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__1" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__1__Impl" |
| // InternalEssentialOCL.g:9017:1: rule__NavigatingBarArgCS__Group_2_2__1__Impl : ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) ; |
| public final void rule__NavigatingBarArgCS__Group_2_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9021:1: ( ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) ) |
| // InternalEssentialOCL.g:9022:1: ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:9022:1: ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) |
| // InternalEssentialOCL.g:9023:1: ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionAssignment_2_2_1()); |
| } |
| // InternalEssentialOCL.g:9024:1: ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) |
| // InternalEssentialOCL.g:9024:2: rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionAssignment_2_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group__0" |
| // InternalEssentialOCL.g:9038:1: rule__NavigatingCommaArgCS__Group__0 : rule__NavigatingCommaArgCS__Group__0__Impl rule__NavigatingCommaArgCS__Group__1 ; |
| public final void rule__NavigatingCommaArgCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9042:1: ( rule__NavigatingCommaArgCS__Group__0__Impl rule__NavigatingCommaArgCS__Group__1 ) |
| // InternalEssentialOCL.g:9043:2: rule__NavigatingCommaArgCS__Group__0__Impl rule__NavigatingCommaArgCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NavigatingCommaArgCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group__0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group__0__Impl" |
| // InternalEssentialOCL.g:9050:1: rule__NavigatingCommaArgCS__Group__0__Impl : ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9054:1: ( ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:9055:1: ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:9055:1: ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) ) |
| // InternalEssentialOCL.g:9056:1: ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixAssignment_0()); |
| } |
| // InternalEssentialOCL.g:9057:1: ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) |
| // InternalEssentialOCL.g:9057:2: rule__NavigatingCommaArgCS__PrefixAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__PrefixAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group__1" |
| // InternalEssentialOCL.g:9067:1: rule__NavigatingCommaArgCS__Group__1 : rule__NavigatingCommaArgCS__Group__1__Impl rule__NavigatingCommaArgCS__Group__2 ; |
| public final void rule__NavigatingCommaArgCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9071:1: ( rule__NavigatingCommaArgCS__Group__1__Impl rule__NavigatingCommaArgCS__Group__2 ) |
| // InternalEssentialOCL.g:9072:2: rule__NavigatingCommaArgCS__Group__1__Impl rule__NavigatingCommaArgCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_42); |
| rule__NavigatingCommaArgCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group__1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group__1__Impl" |
| // InternalEssentialOCL.g:9079:1: rule__NavigatingCommaArgCS__Group__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9083:1: ( ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) ) ) |
| // InternalEssentialOCL.g:9084:1: ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) ) |
| { |
| // InternalEssentialOCL.g:9084:1: ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) ) |
| // InternalEssentialOCL.g:9085:1: ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionAssignment_1()); |
| } |
| // InternalEssentialOCL.g:9086:1: ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) |
| // InternalEssentialOCL.g:9086:2: rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group__2" |
| // InternalEssentialOCL.g:9096:1: rule__NavigatingCommaArgCS__Group__2 : rule__NavigatingCommaArgCS__Group__2__Impl ; |
| public final void rule__NavigatingCommaArgCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9100:1: ( rule__NavigatingCommaArgCS__Group__2__Impl ) |
| // InternalEssentialOCL.g:9101:2: rule__NavigatingCommaArgCS__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group__2" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group__2__Impl" |
| // InternalEssentialOCL.g:9107:1: rule__NavigatingCommaArgCS__Group__2__Impl : ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? ) ; |
| public final void rule__NavigatingCommaArgCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9111:1: ( ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? ) ) |
| // InternalEssentialOCL.g:9112:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? ) |
| { |
| // InternalEssentialOCL.g:9112:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? ) |
| // InternalEssentialOCL.g:9113:1: ( rule__NavigatingCommaArgCS__Alternatives_2 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2()); |
| } |
| // InternalEssentialOCL.g:9114:1: ( rule__NavigatingCommaArgCS__Alternatives_2 )? |
| int alt77=2; |
| int LA77_0 = input.LA(1); |
| |
| if ( ((LA77_0>=55 && LA77_0<=56)||LA77_0==62||LA77_0==73) ) { |
| alt77=1; |
| } |
| switch (alt77) { |
| case 1 : |
| // InternalEssentialOCL.g:9114:2: rule__NavigatingCommaArgCS__Alternatives_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Alternatives_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__0" |
| // InternalEssentialOCL.g:9130:1: rule__NavigatingCommaArgCS__Group_2_0__0 : rule__NavigatingCommaArgCS__Group_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_0__1 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9134:1: ( rule__NavigatingCommaArgCS__Group_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_0__1 ) |
| // InternalEssentialOCL.g:9135:2: rule__NavigatingCommaArgCS__Group_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__NavigatingCommaArgCS__Group_2_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__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__NavigatingCommaArgCS__Group_2_0__0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__0__Impl" |
| // InternalEssentialOCL.g:9142:1: rule__NavigatingCommaArgCS__Group_2_0__0__Impl : ( ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9146:1: ( ( ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 ) ) ) |
| // InternalEssentialOCL.g:9147:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 ) ) |
| { |
| // InternalEssentialOCL.g:9147:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 ) ) |
| // InternalEssentialOCL.g:9148:1: ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_0_0()); |
| } |
| // InternalEssentialOCL.g:9149:1: ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 ) |
| // InternalEssentialOCL.g:9149:2: rule__NavigatingCommaArgCS__Alternatives_2_0_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Alternatives_2_0_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__1" |
| // InternalEssentialOCL.g:9159:1: rule__NavigatingCommaArgCS__Group_2_0__1 : rule__NavigatingCommaArgCS__Group_2_0__1__Impl rule__NavigatingCommaArgCS__Group_2_0__2 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9163:1: ( rule__NavigatingCommaArgCS__Group_2_0__1__Impl rule__NavigatingCommaArgCS__Group_2_0__2 ) |
| // InternalEssentialOCL.g:9164:2: rule__NavigatingCommaArgCS__Group_2_0__1__Impl rule__NavigatingCommaArgCS__Group_2_0__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__NavigatingCommaArgCS__Group_2_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__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__NavigatingCommaArgCS__Group_2_0__1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__1__Impl" |
| // InternalEssentialOCL.g:9171:1: rule__NavigatingCommaArgCS__Group_2_0__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9175:1: ( ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) ) ) |
| // InternalEssentialOCL.g:9176:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) ) |
| { |
| // InternalEssentialOCL.g:9176:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) ) |
| // InternalEssentialOCL.g:9177:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_0_1()); |
| } |
| // InternalEssentialOCL.g:9178:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) |
| // InternalEssentialOCL.g:9178:2: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__2" |
| // InternalEssentialOCL.g:9188:1: rule__NavigatingCommaArgCS__Group_2_0__2 : rule__NavigatingCommaArgCS__Group_2_0__2__Impl ; |
| public final void rule__NavigatingCommaArgCS__Group_2_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9192:1: ( rule__NavigatingCommaArgCS__Group_2_0__2__Impl ) |
| // InternalEssentialOCL.g:9193:2: rule__NavigatingCommaArgCS__Group_2_0__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__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__NavigatingCommaArgCS__Group_2_0__2" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__2__Impl" |
| // InternalEssentialOCL.g:9199:1: rule__NavigatingCommaArgCS__Group_2_0__2__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9203:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? ) ) |
| // InternalEssentialOCL.g:9204:1: ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:9204:1: ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? ) |
| // InternalEssentialOCL.g:9205:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0_2()); |
| } |
| // InternalEssentialOCL.g:9206:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? |
| int alt78=2; |
| int LA78_0 = input.LA(1); |
| |
| if ( (LA78_0==26) ) { |
| alt78=1; |
| } |
| switch (alt78) { |
| case 1 : |
| // InternalEssentialOCL.g:9206:2: rule__NavigatingCommaArgCS__Group_2_0_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_0_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__0" |
| // InternalEssentialOCL.g:9222:1: rule__NavigatingCommaArgCS__Group_2_0_2__0 : rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl rule__NavigatingCommaArgCS__Group_2_0_2__1 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_0_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9226:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl rule__NavigatingCommaArgCS__Group_2_0_2__1 ) |
| // InternalEssentialOCL.g:9227:2: rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl rule__NavigatingCommaArgCS__Group_2_0_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_0_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl" |
| // InternalEssentialOCL.g:9234:1: rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl : ( '=' ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9238:1: ( ( '=' ) ) |
| // InternalEssentialOCL.g:9239:1: ( '=' ) |
| { |
| // InternalEssentialOCL.g:9239:1: ( '=' ) |
| // InternalEssentialOCL.g:9240:1: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_0_2_0()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_0_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__1" |
| // InternalEssentialOCL.g:9253:1: rule__NavigatingCommaArgCS__Group_2_0_2__1 : rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl ; |
| public final void rule__NavigatingCommaArgCS__Group_2_0_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9257:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl ) |
| // InternalEssentialOCL.g:9258:2: rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl" |
| // InternalEssentialOCL.g:9264:1: rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9268:1: ( ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) ) ) |
| // InternalEssentialOCL.g:9269:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:9269:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) ) |
| // InternalEssentialOCL.g:9270:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_0_2_1()); |
| } |
| // InternalEssentialOCL.g:9271:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) |
| // InternalEssentialOCL.g:9271:2: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_0_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__0" |
| // InternalEssentialOCL.g:9285:1: rule__NavigatingCommaArgCS__Group_2_1__0 : rule__NavigatingCommaArgCS__Group_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_1__1 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9289:1: ( rule__NavigatingCommaArgCS__Group_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_1__1 ) |
| // InternalEssentialOCL.g:9290:2: rule__NavigatingCommaArgCS__Group_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__NavigatingCommaArgCS__Group_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__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__NavigatingCommaArgCS__Group_2_1__0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__0__Impl" |
| // InternalEssentialOCL.g:9297:1: rule__NavigatingCommaArgCS__Group_2_1__0__Impl : ( ':' ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9301:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:9302:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:9302:1: ( ':' ) |
| // InternalEssentialOCL.g:9303:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_1_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__1" |
| // InternalEssentialOCL.g:9316:1: rule__NavigatingCommaArgCS__Group_2_1__1 : rule__NavigatingCommaArgCS__Group_2_1__1__Impl rule__NavigatingCommaArgCS__Group_2_1__2 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9320:1: ( rule__NavigatingCommaArgCS__Group_2_1__1__Impl rule__NavigatingCommaArgCS__Group_2_1__2 ) |
| // InternalEssentialOCL.g:9321:2: rule__NavigatingCommaArgCS__Group_2_1__1__Impl rule__NavigatingCommaArgCS__Group_2_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_43); |
| rule__NavigatingCommaArgCS__Group_2_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__1__Impl" |
| // InternalEssentialOCL.g:9328:1: rule__NavigatingCommaArgCS__Group_2_1__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9332:1: ( ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) ) ) |
| // InternalEssentialOCL.g:9333:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:9333:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) ) |
| // InternalEssentialOCL.g:9334:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_1_1()); |
| } |
| // InternalEssentialOCL.g:9335:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) |
| // InternalEssentialOCL.g:9335:2: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__2" |
| // InternalEssentialOCL.g:9345:1: rule__NavigatingCommaArgCS__Group_2_1__2 : rule__NavigatingCommaArgCS__Group_2_1__2__Impl rule__NavigatingCommaArgCS__Group_2_1__3 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9349:1: ( rule__NavigatingCommaArgCS__Group_2_1__2__Impl rule__NavigatingCommaArgCS__Group_2_1__3 ) |
| // InternalEssentialOCL.g:9350:2: rule__NavigatingCommaArgCS__Group_2_1__2__Impl rule__NavigatingCommaArgCS__Group_2_1__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_43); |
| rule__NavigatingCommaArgCS__Group_2_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__2" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__2__Impl" |
| // InternalEssentialOCL.g:9357:1: rule__NavigatingCommaArgCS__Group_2_1__2__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9361:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? ) ) |
| // InternalEssentialOCL.g:9362:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:9362:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? ) |
| // InternalEssentialOCL.g:9363:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_2()); |
| } |
| // InternalEssentialOCL.g:9364:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? |
| int alt79=2; |
| int LA79_0 = input.LA(1); |
| |
| if ( ((LA79_0>=55 && LA79_0<=56)) ) { |
| alt79=1; |
| } |
| switch (alt79) { |
| case 1 : |
| // InternalEssentialOCL.g:9364:2: rule__NavigatingCommaArgCS__Group_2_1_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_1_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__3" |
| // InternalEssentialOCL.g:9374:1: rule__NavigatingCommaArgCS__Group_2_1__3 : rule__NavigatingCommaArgCS__Group_2_1__3__Impl ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9378:1: ( rule__NavigatingCommaArgCS__Group_2_1__3__Impl ) |
| // InternalEssentialOCL.g:9379:2: rule__NavigatingCommaArgCS__Group_2_1__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_1__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__3" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__3__Impl" |
| // InternalEssentialOCL.g:9385:1: rule__NavigatingCommaArgCS__Group_2_1__3__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9389:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? ) ) |
| // InternalEssentialOCL.g:9390:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? ) |
| { |
| // InternalEssentialOCL.g:9390:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? ) |
| // InternalEssentialOCL.g:9391:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_3()); |
| } |
| // InternalEssentialOCL.g:9392:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? |
| int alt80=2; |
| int LA80_0 = input.LA(1); |
| |
| if ( (LA80_0==26) ) { |
| alt80=1; |
| } |
| switch (alt80) { |
| case 1 : |
| // InternalEssentialOCL.g:9392:2: rule__NavigatingCommaArgCS__Group_2_1_3__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_1_3__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__0" |
| // InternalEssentialOCL.g:9410:1: rule__NavigatingCommaArgCS__Group_2_1_2__0 : rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl rule__NavigatingCommaArgCS__Group_2_1_2__1 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9414:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl rule__NavigatingCommaArgCS__Group_2_1_2__1 ) |
| // InternalEssentialOCL.g:9415:2: rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl rule__NavigatingCommaArgCS__Group_2_1_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_1_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl" |
| // InternalEssentialOCL.g:9422:1: rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl : ( ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9426:1: ( ( ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 ) ) ) |
| // InternalEssentialOCL.g:9427:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 ) ) |
| { |
| // InternalEssentialOCL.g:9427:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 ) ) |
| // InternalEssentialOCL.g:9428:1: ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_1_2_0()); |
| } |
| // InternalEssentialOCL.g:9429:1: ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 ) |
| // InternalEssentialOCL.g:9429:2: rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Alternatives_2_1_2_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__1" |
| // InternalEssentialOCL.g:9439:1: rule__NavigatingCommaArgCS__Group_2_1_2__1 : rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9443:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl ) |
| // InternalEssentialOCL.g:9444:2: rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl" |
| // InternalEssentialOCL.g:9450:1: rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9454:1: ( ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) ) ) |
| // InternalEssentialOCL.g:9455:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:9455:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) ) |
| // InternalEssentialOCL.g:9456:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_1_2_1()); |
| } |
| // InternalEssentialOCL.g:9457:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) |
| // InternalEssentialOCL.g:9457:2: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_1_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__0" |
| // InternalEssentialOCL.g:9471:1: rule__NavigatingCommaArgCS__Group_2_1_3__0 : rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl rule__NavigatingCommaArgCS__Group_2_1_3__1 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9475:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl rule__NavigatingCommaArgCS__Group_2_1_3__1 ) |
| // InternalEssentialOCL.g:9476:2: rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl rule__NavigatingCommaArgCS__Group_2_1_3__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_1_3__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_3__0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl" |
| // InternalEssentialOCL.g:9483:1: rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl : ( '=' ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9487:1: ( ( '=' ) ) |
| // InternalEssentialOCL.g:9488:1: ( '=' ) |
| { |
| // InternalEssentialOCL.g:9488:1: ( '=' ) |
| // InternalEssentialOCL.g:9489:1: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_1_3_0()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_1_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__1" |
| // InternalEssentialOCL.g:9502:1: rule__NavigatingCommaArgCS__Group_2_1_3__1 : rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9506:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl ) |
| // InternalEssentialOCL.g:9507:2: rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_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__NavigatingCommaArgCS__Group_2_1_3__1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl" |
| // InternalEssentialOCL.g:9513:1: rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9517:1: ( ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) ) ) |
| // InternalEssentialOCL.g:9518:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) ) |
| { |
| // InternalEssentialOCL.g:9518:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) ) |
| // InternalEssentialOCL.g:9519:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_1_3_1()); |
| } |
| // InternalEssentialOCL.g:9520:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) |
| // InternalEssentialOCL.g:9520:2: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_1_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__0" |
| // InternalEssentialOCL.g:9534:1: rule__NavigatingCommaArgCS__Group_2_2__0 : rule__NavigatingCommaArgCS__Group_2_2__0__Impl rule__NavigatingCommaArgCS__Group_2_2__1 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9538:1: ( rule__NavigatingCommaArgCS__Group_2_2__0__Impl rule__NavigatingCommaArgCS__Group_2_2__1 ) |
| // InternalEssentialOCL.g:9539:2: rule__NavigatingCommaArgCS__Group_2_2__0__Impl rule__NavigatingCommaArgCS__Group_2_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_42); |
| rule__NavigatingCommaArgCS__Group_2_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__0__Impl" |
| // InternalEssentialOCL.g:9546:1: rule__NavigatingCommaArgCS__Group_2_2__0__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9550:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? ) ) |
| // InternalEssentialOCL.g:9551:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? ) |
| { |
| // InternalEssentialOCL.g:9551:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? ) |
| // InternalEssentialOCL.g:9552:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_0()); |
| } |
| // InternalEssentialOCL.g:9553:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? |
| int alt81=2; |
| int LA81_0 = input.LA(1); |
| |
| if ( (LA81_0==62) ) { |
| alt81=1; |
| } |
| switch (alt81) { |
| case 1 : |
| // InternalEssentialOCL.g:9553:2: rule__NavigatingCommaArgCS__Group_2_2_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_2_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__1" |
| // InternalEssentialOCL.g:9563:1: rule__NavigatingCommaArgCS__Group_2_2__1 : rule__NavigatingCommaArgCS__Group_2_2__1__Impl rule__NavigatingCommaArgCS__Group_2_2__2 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9567:1: ( rule__NavigatingCommaArgCS__Group_2_2__1__Impl rule__NavigatingCommaArgCS__Group_2_2__2 ) |
| // InternalEssentialOCL.g:9568:2: rule__NavigatingCommaArgCS__Group_2_2__1__Impl rule__NavigatingCommaArgCS__Group_2_2__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_42); |
| rule__NavigatingCommaArgCS__Group_2_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_2__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__1__Impl" |
| // InternalEssentialOCL.g:9575:1: rule__NavigatingCommaArgCS__Group_2_2__1__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9579:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? ) ) |
| // InternalEssentialOCL.g:9580:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:9580:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? ) |
| // InternalEssentialOCL.g:9581:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_1()); |
| } |
| // InternalEssentialOCL.g:9582:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? |
| int alt82=2; |
| int LA82_0 = input.LA(1); |
| |
| if ( ((LA82_0>=55 && LA82_0<=56)) ) { |
| alt82=1; |
| } |
| switch (alt82) { |
| case 1 : |
| // InternalEssentialOCL.g:9582:2: rule__NavigatingCommaArgCS__Group_2_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__2" |
| // InternalEssentialOCL.g:9592:1: rule__NavigatingCommaArgCS__Group_2_2__2 : rule__NavigatingCommaArgCS__Group_2_2__2__Impl rule__NavigatingCommaArgCS__Group_2_2__3 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9596:1: ( rule__NavigatingCommaArgCS__Group_2_2__2__Impl rule__NavigatingCommaArgCS__Group_2_2__3 ) |
| // InternalEssentialOCL.g:9597:2: rule__NavigatingCommaArgCS__Group_2_2__2__Impl rule__NavigatingCommaArgCS__Group_2_2__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NavigatingCommaArgCS__Group_2_2__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_2__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__2" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__2__Impl" |
| // InternalEssentialOCL.g:9604:1: rule__NavigatingCommaArgCS__Group_2_2__2__Impl : ( 'in' ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9608:1: ( ( 'in' ) ) |
| // InternalEssentialOCL.g:9609:1: ( 'in' ) |
| { |
| // InternalEssentialOCL.g:9609:1: ( 'in' ) |
| // InternalEssentialOCL.g:9610:1: 'in' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getInKeyword_2_2_2()); |
| } |
| match(input,73,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getInKeyword_2_2_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__2__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__3" |
| // InternalEssentialOCL.g:9623:1: rule__NavigatingCommaArgCS__Group_2_2__3 : rule__NavigatingCommaArgCS__Group_2_2__3__Impl ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9627:1: ( rule__NavigatingCommaArgCS__Group_2_2__3__Impl ) |
| // InternalEssentialOCL.g:9628:2: rule__NavigatingCommaArgCS__Group_2_2__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_2__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__3" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__3__Impl" |
| // InternalEssentialOCL.g:9634:1: rule__NavigatingCommaArgCS__Group_2_2__3__Impl : ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9638:1: ( ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) ) ) |
| // InternalEssentialOCL.g:9639:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) ) |
| { |
| // InternalEssentialOCL.g:9639:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) ) |
| // InternalEssentialOCL.g:9640:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_2_3()); |
| } |
| // InternalEssentialOCL.g:9641:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) |
| // InternalEssentialOCL.g:9641:2: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_2_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__3__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__0" |
| // InternalEssentialOCL.g:9659:1: rule__NavigatingCommaArgCS__Group_2_2_0__0 : rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_2_0__1 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9663:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_2_0__1 ) |
| // InternalEssentialOCL.g:9664:2: rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_2_0__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_2_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl" |
| // InternalEssentialOCL.g:9671:1: rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl : ( ':' ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9675:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:9676:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:9676:1: ( ':' ) |
| // InternalEssentialOCL.g:9677:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_2_0_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__1" |
| // InternalEssentialOCL.g:9690:1: rule__NavigatingCommaArgCS__Group_2_2_0__1 : rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9694:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl ) |
| // InternalEssentialOCL.g:9695:2: rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl" |
| // InternalEssentialOCL.g:9701:1: rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9705:1: ( ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) ) ) |
| // InternalEssentialOCL.g:9706:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) ) |
| { |
| // InternalEssentialOCL.g:9706:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) ) |
| // InternalEssentialOCL.g:9707:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_2_0_1()); |
| } |
| // InternalEssentialOCL.g:9708:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) |
| // InternalEssentialOCL.g:9708:2: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_2_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__0" |
| // InternalEssentialOCL.g:9722:1: rule__NavigatingCommaArgCS__Group_2_2_1__0 : rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_2_1__1 ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9726:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_2_1__1 ) |
| // InternalEssentialOCL.g:9727:2: rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_2_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_2_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_1__0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl" |
| // InternalEssentialOCL.g:9734:1: rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl : ( ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9738:1: ( ( ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 ) ) ) |
| // InternalEssentialOCL.g:9739:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 ) ) |
| { |
| // InternalEssentialOCL.g:9739:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 ) ) |
| // InternalEssentialOCL.g:9740:1: ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_2_1_0()); |
| } |
| // InternalEssentialOCL.g:9741:1: ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 ) |
| // InternalEssentialOCL.g:9741:2: rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Alternatives_2_2_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__1" |
| // InternalEssentialOCL.g:9751:1: rule__NavigatingCommaArgCS__Group_2_2_1__1 : rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9755:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl ) |
| // InternalEssentialOCL.g:9756:2: rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_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__NavigatingCommaArgCS__Group_2_2_1__1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl" |
| // InternalEssentialOCL.g:9762:1: rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) ) ; |
| public final void rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9766:1: ( ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) ) ) |
| // InternalEssentialOCL.g:9767:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:9767:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) ) |
| // InternalEssentialOCL.g:9768:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_2_1_1()); |
| } |
| // InternalEssentialOCL.g:9769:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) |
| // InternalEssentialOCL.g:9769:2: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group__0" |
| // InternalEssentialOCL.g:9783:1: rule__NavigatingSemiArgCS__Group__0 : rule__NavigatingSemiArgCS__Group__0__Impl rule__NavigatingSemiArgCS__Group__1 ; |
| public final void rule__NavigatingSemiArgCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9787:1: ( rule__NavigatingSemiArgCS__Group__0__Impl rule__NavigatingSemiArgCS__Group__1 ) |
| // InternalEssentialOCL.g:9788:2: rule__NavigatingSemiArgCS__Group__0__Impl rule__NavigatingSemiArgCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NavigatingSemiArgCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group__0" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group__0__Impl" |
| // InternalEssentialOCL.g:9795:1: rule__NavigatingSemiArgCS__Group__0__Impl : ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) ) ; |
| public final void rule__NavigatingSemiArgCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9799:1: ( ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:9800:1: ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:9800:1: ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) ) |
| // InternalEssentialOCL.g:9801:1: ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixAssignment_0()); |
| } |
| // InternalEssentialOCL.g:9802:1: ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) |
| // InternalEssentialOCL.g:9802:2: rule__NavigatingSemiArgCS__PrefixAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__PrefixAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group__1" |
| // InternalEssentialOCL.g:9812:1: rule__NavigatingSemiArgCS__Group__1 : rule__NavigatingSemiArgCS__Group__1__Impl rule__NavigatingSemiArgCS__Group__2 ; |
| public final void rule__NavigatingSemiArgCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9816:1: ( rule__NavigatingSemiArgCS__Group__1__Impl rule__NavigatingSemiArgCS__Group__2 ) |
| // InternalEssentialOCL.g:9817:2: rule__NavigatingSemiArgCS__Group__1__Impl rule__NavigatingSemiArgCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__NavigatingSemiArgCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group__1" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group__1__Impl" |
| // InternalEssentialOCL.g:9824:1: rule__NavigatingSemiArgCS__Group__1__Impl : ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) ) ; |
| public final void rule__NavigatingSemiArgCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9828:1: ( ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) ) ) |
| // InternalEssentialOCL.g:9829:1: ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) ) |
| { |
| // InternalEssentialOCL.g:9829:1: ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) ) |
| // InternalEssentialOCL.g:9830:1: ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionAssignment_1()); |
| } |
| // InternalEssentialOCL.g:9831:1: ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) |
| // InternalEssentialOCL.g:9831:2: rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group__2" |
| // InternalEssentialOCL.g:9841:1: rule__NavigatingSemiArgCS__Group__2 : rule__NavigatingSemiArgCS__Group__2__Impl ; |
| public final void rule__NavigatingSemiArgCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9845:1: ( rule__NavigatingSemiArgCS__Group__2__Impl ) |
| // InternalEssentialOCL.g:9846:2: rule__NavigatingSemiArgCS__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group__2" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group__2__Impl" |
| // InternalEssentialOCL.g:9852:1: rule__NavigatingSemiArgCS__Group__2__Impl : ( ( rule__NavigatingSemiArgCS__Group_2__0 )? ) ; |
| public final void rule__NavigatingSemiArgCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9856:1: ( ( ( rule__NavigatingSemiArgCS__Group_2__0 )? ) ) |
| // InternalEssentialOCL.g:9857:1: ( ( rule__NavigatingSemiArgCS__Group_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:9857:1: ( ( rule__NavigatingSemiArgCS__Group_2__0 )? ) |
| // InternalEssentialOCL.g:9858:1: ( rule__NavigatingSemiArgCS__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2()); |
| } |
| // InternalEssentialOCL.g:9859:1: ( rule__NavigatingSemiArgCS__Group_2__0 )? |
| int alt83=2; |
| int LA83_0 = input.LA(1); |
| |
| if ( (LA83_0==62) ) { |
| alt83=1; |
| } |
| switch (alt83) { |
| case 1 : |
| // InternalEssentialOCL.g:9859:2: rule__NavigatingSemiArgCS__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__0" |
| // InternalEssentialOCL.g:9875:1: rule__NavigatingSemiArgCS__Group_2__0 : rule__NavigatingSemiArgCS__Group_2__0__Impl rule__NavigatingSemiArgCS__Group_2__1 ; |
| public final void rule__NavigatingSemiArgCS__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9879:1: ( rule__NavigatingSemiArgCS__Group_2__0__Impl rule__NavigatingSemiArgCS__Group_2__1 ) |
| // InternalEssentialOCL.g:9880:2: rule__NavigatingSemiArgCS__Group_2__0__Impl rule__NavigatingSemiArgCS__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__NavigatingSemiArgCS__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__0" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__0__Impl" |
| // InternalEssentialOCL.g:9887:1: rule__NavigatingSemiArgCS__Group_2__0__Impl : ( ':' ) ; |
| public final void rule__NavigatingSemiArgCS__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9891:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:9892:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:9892:1: ( ':' ) |
| // InternalEssentialOCL.g:9893:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getColonKeyword_2_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getColonKeyword_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__1" |
| // InternalEssentialOCL.g:9906:1: rule__NavigatingSemiArgCS__Group_2__1 : rule__NavigatingSemiArgCS__Group_2__1__Impl rule__NavigatingSemiArgCS__Group_2__2 ; |
| public final void rule__NavigatingSemiArgCS__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9910:1: ( rule__NavigatingSemiArgCS__Group_2__1__Impl rule__NavigatingSemiArgCS__Group_2__2 ) |
| // InternalEssentialOCL.g:9911:2: rule__NavigatingSemiArgCS__Group_2__1__Impl rule__NavigatingSemiArgCS__Group_2__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_20); |
| rule__NavigatingSemiArgCS__Group_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__Group_2__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__1" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__1__Impl" |
| // InternalEssentialOCL.g:9918:1: rule__NavigatingSemiArgCS__Group_2__1__Impl : ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) ) ; |
| public final void rule__NavigatingSemiArgCS__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9922:1: ( ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) ) ) |
| // InternalEssentialOCL.g:9923:1: ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:9923:1: ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) ) |
| // InternalEssentialOCL.g:9924:1: ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeAssignment_2_1()); |
| } |
| // InternalEssentialOCL.g:9925:1: ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) |
| // InternalEssentialOCL.g:9925:2: rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeAssignment_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__2" |
| // InternalEssentialOCL.g:9935:1: rule__NavigatingSemiArgCS__Group_2__2 : rule__NavigatingSemiArgCS__Group_2__2__Impl ; |
| public final void rule__NavigatingSemiArgCS__Group_2__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9939:1: ( rule__NavigatingSemiArgCS__Group_2__2__Impl ) |
| // InternalEssentialOCL.g:9940:2: rule__NavigatingSemiArgCS__Group_2__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__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__NavigatingSemiArgCS__Group_2__2" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__2__Impl" |
| // InternalEssentialOCL.g:9946:1: rule__NavigatingSemiArgCS__Group_2__2__Impl : ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? ) ; |
| public final void rule__NavigatingSemiArgCS__Group_2__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9950:1: ( ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? ) ) |
| // InternalEssentialOCL.g:9951:1: ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:9951:1: ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? ) |
| // InternalEssentialOCL.g:9952:1: ( rule__NavigatingSemiArgCS__Group_2_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2_2()); |
| } |
| // InternalEssentialOCL.g:9953:1: ( rule__NavigatingSemiArgCS__Group_2_2__0 )? |
| int alt84=2; |
| int LA84_0 = input.LA(1); |
| |
| if ( (LA84_0==26) ) { |
| alt84=1; |
| } |
| switch (alt84) { |
| case 1 : |
| // InternalEssentialOCL.g:9953:2: rule__NavigatingSemiArgCS__Group_2_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__Group_2_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__2__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__0" |
| // InternalEssentialOCL.g:9969:1: rule__NavigatingSemiArgCS__Group_2_2__0 : rule__NavigatingSemiArgCS__Group_2_2__0__Impl rule__NavigatingSemiArgCS__Group_2_2__1 ; |
| public final void rule__NavigatingSemiArgCS__Group_2_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9973:1: ( rule__NavigatingSemiArgCS__Group_2_2__0__Impl rule__NavigatingSemiArgCS__Group_2_2__1 ) |
| // InternalEssentialOCL.g:9974:2: rule__NavigatingSemiArgCS__Group_2_2__0__Impl rule__NavigatingSemiArgCS__Group_2_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NavigatingSemiArgCS__Group_2_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__Group_2_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__0" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__0__Impl" |
| // InternalEssentialOCL.g:9981:1: rule__NavigatingSemiArgCS__Group_2_2__0__Impl : ( '=' ) ; |
| public final void rule__NavigatingSemiArgCS__Group_2_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:9985:1: ( ( '=' ) ) |
| // InternalEssentialOCL.g:9986:1: ( '=' ) |
| { |
| // InternalEssentialOCL.g:9986:1: ( '=' ) |
| // InternalEssentialOCL.g:9987:1: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getEqualsSignKeyword_2_2_0()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getEqualsSignKeyword_2_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__1" |
| // InternalEssentialOCL.g:10000:1: rule__NavigatingSemiArgCS__Group_2_2__1 : rule__NavigatingSemiArgCS__Group_2_2__1__Impl ; |
| public final void rule__NavigatingSemiArgCS__Group_2_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10004:1: ( rule__NavigatingSemiArgCS__Group_2_2__1__Impl ) |
| // InternalEssentialOCL.g:10005:2: rule__NavigatingSemiArgCS__Group_2_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__Group_2_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__1" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__1__Impl" |
| // InternalEssentialOCL.g:10011:1: rule__NavigatingSemiArgCS__Group_2_2__1__Impl : ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) ; |
| public final void rule__NavigatingSemiArgCS__Group_2_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10015:1: ( ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) ) |
| // InternalEssentialOCL.g:10016:1: ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:10016:1: ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) |
| // InternalEssentialOCL.g:10017:1: ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionAssignment_2_2_1()); |
| } |
| // InternalEssentialOCL.g:10018:1: ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) |
| // InternalEssentialOCL.g:10018:2: rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionAssignment_2_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__CoIteratorVariableCS__Group__0" |
| // InternalEssentialOCL.g:10032:1: rule__CoIteratorVariableCS__Group__0 : rule__CoIteratorVariableCS__Group__0__Impl rule__CoIteratorVariableCS__Group__1 ; |
| public final void rule__CoIteratorVariableCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10036:1: ( rule__CoIteratorVariableCS__Group__0__Impl rule__CoIteratorVariableCS__Group__1 ) |
| // InternalEssentialOCL.g:10037:2: rule__CoIteratorVariableCS__Group__0__Impl rule__CoIteratorVariableCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_13); |
| rule__CoIteratorVariableCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CoIteratorVariableCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CoIteratorVariableCS__Group__0" |
| |
| |
| // $ANTLR start "rule__CoIteratorVariableCS__Group__0__Impl" |
| // InternalEssentialOCL.g:10044:1: rule__CoIteratorVariableCS__Group__0__Impl : ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) ) ; |
| public final void rule__CoIteratorVariableCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10048:1: ( ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:10049:1: ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:10049:1: ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) ) |
| // InternalEssentialOCL.g:10050:1: ( rule__CoIteratorVariableCS__NameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCoIteratorVariableCSAccess().getNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:10051:1: ( rule__CoIteratorVariableCS__NameAssignment_0 ) |
| // InternalEssentialOCL.g:10051:2: rule__CoIteratorVariableCS__NameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CoIteratorVariableCS__NameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCoIteratorVariableCSAccess().getNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CoIteratorVariableCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__CoIteratorVariableCS__Group__1" |
| // InternalEssentialOCL.g:10061:1: rule__CoIteratorVariableCS__Group__1 : rule__CoIteratorVariableCS__Group__1__Impl ; |
| public final void rule__CoIteratorVariableCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10065:1: ( rule__CoIteratorVariableCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:10066:2: rule__CoIteratorVariableCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CoIteratorVariableCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CoIteratorVariableCS__Group__1" |
| |
| |
| // $ANTLR start "rule__CoIteratorVariableCS__Group__1__Impl" |
| // InternalEssentialOCL.g:10072:1: rule__CoIteratorVariableCS__Group__1__Impl : ( ( rule__CoIteratorVariableCS__Group_1__0 )? ) ; |
| public final void rule__CoIteratorVariableCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10076:1: ( ( ( rule__CoIteratorVariableCS__Group_1__0 )? ) ) |
| // InternalEssentialOCL.g:10077:1: ( ( rule__CoIteratorVariableCS__Group_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:10077:1: ( ( rule__CoIteratorVariableCS__Group_1__0 )? ) |
| // InternalEssentialOCL.g:10078:1: ( rule__CoIteratorVariableCS__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCoIteratorVariableCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:10079:1: ( rule__CoIteratorVariableCS__Group_1__0 )? |
| int alt85=2; |
| int LA85_0 = input.LA(1); |
| |
| if ( (LA85_0==62) ) { |
| alt85=1; |
| } |
| switch (alt85) { |
| case 1 : |
| // InternalEssentialOCL.g:10079:2: rule__CoIteratorVariableCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CoIteratorVariableCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCoIteratorVariableCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CoIteratorVariableCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__CoIteratorVariableCS__Group_1__0" |
| // InternalEssentialOCL.g:10093:1: rule__CoIteratorVariableCS__Group_1__0 : rule__CoIteratorVariableCS__Group_1__0__Impl rule__CoIteratorVariableCS__Group_1__1 ; |
| public final void rule__CoIteratorVariableCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10097:1: ( rule__CoIteratorVariableCS__Group_1__0__Impl rule__CoIteratorVariableCS__Group_1__1 ) |
| // InternalEssentialOCL.g:10098:2: rule__CoIteratorVariableCS__Group_1__0__Impl rule__CoIteratorVariableCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__CoIteratorVariableCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CoIteratorVariableCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CoIteratorVariableCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__CoIteratorVariableCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:10105:1: rule__CoIteratorVariableCS__Group_1__0__Impl : ( ':' ) ; |
| public final void rule__CoIteratorVariableCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10109:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:10110:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:10110:1: ( ':' ) |
| // InternalEssentialOCL.g:10111:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCoIteratorVariableCSAccess().getColonKeyword_1_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCoIteratorVariableCSAccess().getColonKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CoIteratorVariableCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__CoIteratorVariableCS__Group_1__1" |
| // InternalEssentialOCL.g:10124:1: rule__CoIteratorVariableCS__Group_1__1 : rule__CoIteratorVariableCS__Group_1__1__Impl ; |
| public final void rule__CoIteratorVariableCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10128:1: ( rule__CoIteratorVariableCS__Group_1__1__Impl ) |
| // InternalEssentialOCL.g:10129:2: rule__CoIteratorVariableCS__Group_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CoIteratorVariableCS__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__CoIteratorVariableCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__CoIteratorVariableCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:10135:1: rule__CoIteratorVariableCS__Group_1__1__Impl : ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) ) ; |
| public final void rule__CoIteratorVariableCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10139:1: ( ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) ) ) |
| // InternalEssentialOCL.g:10140:1: ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:10140:1: ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) ) |
| // InternalEssentialOCL.g:10141:1: ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeAssignment_1_1()); |
| } |
| // InternalEssentialOCL.g:10142:1: ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) |
| // InternalEssentialOCL.g:10142:2: rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CoIteratorVariableCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__0" |
| // InternalEssentialOCL.g:10156:1: rule__IfExpCS__Group__0 : rule__IfExpCS__Group__0__Impl rule__IfExpCS__Group__1 ; |
| public final void rule__IfExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10160:1: ( rule__IfExpCS__Group__0__Impl rule__IfExpCS__Group__1 ) |
| // InternalEssentialOCL.g:10161:2: rule__IfExpCS__Group__0__Impl rule__IfExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_16); |
| rule__IfExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:10168:1: rule__IfExpCS__Group__0__Impl : ( 'if' ) ; |
| public final void rule__IfExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10172:1: ( ( 'if' ) ) |
| // InternalEssentialOCL.g:10173:1: ( 'if' ) |
| { |
| // InternalEssentialOCL.g:10173:1: ( 'if' ) |
| // InternalEssentialOCL.g:10174:1: 'if' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getIfKeyword_0()); |
| } |
| match(input,74,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getIfKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__1" |
| // InternalEssentialOCL.g:10187:1: rule__IfExpCS__Group__1 : rule__IfExpCS__Group__1__Impl rule__IfExpCS__Group__2 ; |
| public final void rule__IfExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10191:1: ( rule__IfExpCS__Group__1__Impl rule__IfExpCS__Group__2 ) |
| // InternalEssentialOCL.g:10192:2: rule__IfExpCS__Group__1__Impl rule__IfExpCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_44); |
| rule__IfExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:10199:1: rule__IfExpCS__Group__1__Impl : ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) ) ; |
| public final void rule__IfExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10203:1: ( ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) ) ) |
| // InternalEssentialOCL.g:10204:1: ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) ) |
| { |
| // InternalEssentialOCL.g:10204:1: ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) ) |
| // InternalEssentialOCL.g:10205:1: ( rule__IfExpCS__OwnedConditionAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getOwnedConditionAssignment_1()); |
| } |
| // InternalEssentialOCL.g:10206:1: ( rule__IfExpCS__OwnedConditionAssignment_1 ) |
| // InternalEssentialOCL.g:10206:2: rule__IfExpCS__OwnedConditionAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__OwnedConditionAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getOwnedConditionAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__2" |
| // InternalEssentialOCL.g:10216:1: rule__IfExpCS__Group__2 : rule__IfExpCS__Group__2__Impl rule__IfExpCS__Group__3 ; |
| public final void rule__IfExpCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10220:1: ( rule__IfExpCS__Group__2__Impl rule__IfExpCS__Group__3 ) |
| // InternalEssentialOCL.g:10221:2: rule__IfExpCS__Group__2__Impl rule__IfExpCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__IfExpCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__2" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__2__Impl" |
| // InternalEssentialOCL.g:10228:1: rule__IfExpCS__Group__2__Impl : ( 'then' ) ; |
| public final void rule__IfExpCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10232:1: ( ( 'then' ) ) |
| // InternalEssentialOCL.g:10233:1: ( 'then' ) |
| { |
| // InternalEssentialOCL.g:10233:1: ( 'then' ) |
| // InternalEssentialOCL.g:10234:1: 'then' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getThenKeyword_2()); |
| } |
| match(input,75,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getThenKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__3" |
| // InternalEssentialOCL.g:10247:1: rule__IfExpCS__Group__3 : rule__IfExpCS__Group__3__Impl rule__IfExpCS__Group__4 ; |
| public final void rule__IfExpCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10251:1: ( rule__IfExpCS__Group__3__Impl rule__IfExpCS__Group__4 ) |
| // InternalEssentialOCL.g:10252:2: rule__IfExpCS__Group__3__Impl rule__IfExpCS__Group__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_45); |
| rule__IfExpCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__3" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__3__Impl" |
| // InternalEssentialOCL.g:10259:1: rule__IfExpCS__Group__3__Impl : ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) ) ; |
| public final void rule__IfExpCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10263:1: ( ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) ) ) |
| // InternalEssentialOCL.g:10264:1: ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) ) |
| { |
| // InternalEssentialOCL.g:10264:1: ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) ) |
| // InternalEssentialOCL.g:10265:1: ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionAssignment_3()); |
| } |
| // InternalEssentialOCL.g:10266:1: ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) |
| // InternalEssentialOCL.g:10266:2: rule__IfExpCS__OwnedThenExpressionAssignment_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__OwnedThenExpressionAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__4" |
| // InternalEssentialOCL.g:10276:1: rule__IfExpCS__Group__4 : rule__IfExpCS__Group__4__Impl rule__IfExpCS__Group__5 ; |
| public final void rule__IfExpCS__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10280:1: ( rule__IfExpCS__Group__4__Impl rule__IfExpCS__Group__5 ) |
| // InternalEssentialOCL.g:10281:2: rule__IfExpCS__Group__4__Impl rule__IfExpCS__Group__5 |
| { |
| pushFollow(FollowSets000.FOLLOW_45); |
| rule__IfExpCS__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__Group__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__4" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__4__Impl" |
| // InternalEssentialOCL.g:10288:1: rule__IfExpCS__Group__4__Impl : ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* ) ; |
| public final void rule__IfExpCS__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10292:1: ( ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* ) ) |
| // InternalEssentialOCL.g:10293:1: ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* ) |
| { |
| // InternalEssentialOCL.g:10293:1: ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* ) |
| // InternalEssentialOCL.g:10294:1: ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsAssignment_4()); |
| } |
| // InternalEssentialOCL.g:10295:1: ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* |
| loop86: |
| do { |
| int alt86=2; |
| int LA86_0 = input.LA(1); |
| |
| if ( (LA86_0==78) ) { |
| alt86=1; |
| } |
| |
| |
| switch (alt86) { |
| case 1 : |
| // InternalEssentialOCL.g:10295:2: rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 |
| { |
| pushFollow(FollowSets000.FOLLOW_46); |
| rule__IfExpCS__OwnedIfThenExpressionsAssignment_4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop86; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsAssignment_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__5" |
| // InternalEssentialOCL.g:10305:1: rule__IfExpCS__Group__5 : rule__IfExpCS__Group__5__Impl rule__IfExpCS__Group__6 ; |
| public final void rule__IfExpCS__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10309:1: ( rule__IfExpCS__Group__5__Impl rule__IfExpCS__Group__6 ) |
| // InternalEssentialOCL.g:10310:2: rule__IfExpCS__Group__5__Impl rule__IfExpCS__Group__6 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__IfExpCS__Group__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__Group__6(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__5" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__5__Impl" |
| // InternalEssentialOCL.g:10317:1: rule__IfExpCS__Group__5__Impl : ( 'else' ) ; |
| public final void rule__IfExpCS__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10321:1: ( ( 'else' ) ) |
| // InternalEssentialOCL.g:10322:1: ( 'else' ) |
| { |
| // InternalEssentialOCL.g:10322:1: ( 'else' ) |
| // InternalEssentialOCL.g:10323:1: 'else' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getElseKeyword_5()); |
| } |
| match(input,76,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getElseKeyword_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__6" |
| // InternalEssentialOCL.g:10336:1: rule__IfExpCS__Group__6 : rule__IfExpCS__Group__6__Impl rule__IfExpCS__Group__7 ; |
| public final void rule__IfExpCS__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10340:1: ( rule__IfExpCS__Group__6__Impl rule__IfExpCS__Group__7 ) |
| // InternalEssentialOCL.g:10341:2: rule__IfExpCS__Group__6__Impl rule__IfExpCS__Group__7 |
| { |
| pushFollow(FollowSets000.FOLLOW_47); |
| rule__IfExpCS__Group__6__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__Group__7(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__6" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__6__Impl" |
| // InternalEssentialOCL.g:10348:1: rule__IfExpCS__Group__6__Impl : ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) ) ; |
| public final void rule__IfExpCS__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10352:1: ( ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) ) ) |
| // InternalEssentialOCL.g:10353:1: ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) ) |
| { |
| // InternalEssentialOCL.g:10353:1: ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) ) |
| // InternalEssentialOCL.g:10354:1: ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionAssignment_6()); |
| } |
| // InternalEssentialOCL.g:10355:1: ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) |
| // InternalEssentialOCL.g:10355:2: rule__IfExpCS__OwnedElseExpressionAssignment_6 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__OwnedElseExpressionAssignment_6(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionAssignment_6()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__7" |
| // InternalEssentialOCL.g:10365:1: rule__IfExpCS__Group__7 : rule__IfExpCS__Group__7__Impl ; |
| public final void rule__IfExpCS__Group__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10369:1: ( rule__IfExpCS__Group__7__Impl ) |
| // InternalEssentialOCL.g:10370:2: rule__IfExpCS__Group__7__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__Group__7__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__7" |
| |
| |
| // $ANTLR start "rule__IfExpCS__Group__7__Impl" |
| // InternalEssentialOCL.g:10376:1: rule__IfExpCS__Group__7__Impl : ( 'endif' ) ; |
| public final void rule__IfExpCS__Group__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10380:1: ( ( 'endif' ) ) |
| // InternalEssentialOCL.g:10381:1: ( 'endif' ) |
| { |
| // InternalEssentialOCL.g:10381:1: ( 'endif' ) |
| // InternalEssentialOCL.g:10382:1: 'endif' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getEndifKeyword_7()); |
| } |
| match(input,77,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getEndifKeyword_7()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__Group__7__Impl" |
| |
| |
| // $ANTLR start "rule__ElseIfThenExpCS__Group__0" |
| // InternalEssentialOCL.g:10411:1: rule__ElseIfThenExpCS__Group__0 : rule__ElseIfThenExpCS__Group__0__Impl rule__ElseIfThenExpCS__Group__1 ; |
| public final void rule__ElseIfThenExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10415:1: ( rule__ElseIfThenExpCS__Group__0__Impl rule__ElseIfThenExpCS__Group__1 ) |
| // InternalEssentialOCL.g:10416:2: rule__ElseIfThenExpCS__Group__0__Impl rule__ElseIfThenExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__ElseIfThenExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ElseIfThenExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ElseIfThenExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__ElseIfThenExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:10423:1: rule__ElseIfThenExpCS__Group__0__Impl : ( 'elseif' ) ; |
| public final void rule__ElseIfThenExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10427:1: ( ( 'elseif' ) ) |
| // InternalEssentialOCL.g:10428:1: ( 'elseif' ) |
| { |
| // InternalEssentialOCL.g:10428:1: ( 'elseif' ) |
| // InternalEssentialOCL.g:10429:1: 'elseif' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getElseIfThenExpCSAccess().getElseifKeyword_0()); |
| } |
| match(input,78,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getElseIfThenExpCSAccess().getElseifKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ElseIfThenExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ElseIfThenExpCS__Group__1" |
| // InternalEssentialOCL.g:10442:1: rule__ElseIfThenExpCS__Group__1 : rule__ElseIfThenExpCS__Group__1__Impl rule__ElseIfThenExpCS__Group__2 ; |
| public final void rule__ElseIfThenExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10446:1: ( rule__ElseIfThenExpCS__Group__1__Impl rule__ElseIfThenExpCS__Group__2 ) |
| // InternalEssentialOCL.g:10447:2: rule__ElseIfThenExpCS__Group__1__Impl rule__ElseIfThenExpCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_44); |
| rule__ElseIfThenExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ElseIfThenExpCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ElseIfThenExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__ElseIfThenExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:10454:1: rule__ElseIfThenExpCS__Group__1__Impl : ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) ) ; |
| public final void rule__ElseIfThenExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10458:1: ( ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) ) ) |
| // InternalEssentialOCL.g:10459:1: ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) ) |
| { |
| // InternalEssentialOCL.g:10459:1: ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) ) |
| // InternalEssentialOCL.g:10460:1: ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionAssignment_1()); |
| } |
| // InternalEssentialOCL.g:10461:1: ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) |
| // InternalEssentialOCL.g:10461:2: rule__ElseIfThenExpCS__OwnedConditionAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ElseIfThenExpCS__OwnedConditionAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ElseIfThenExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__ElseIfThenExpCS__Group__2" |
| // InternalEssentialOCL.g:10471:1: rule__ElseIfThenExpCS__Group__2 : rule__ElseIfThenExpCS__Group__2__Impl rule__ElseIfThenExpCS__Group__3 ; |
| public final void rule__ElseIfThenExpCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10475:1: ( rule__ElseIfThenExpCS__Group__2__Impl rule__ElseIfThenExpCS__Group__3 ) |
| // InternalEssentialOCL.g:10476:2: rule__ElseIfThenExpCS__Group__2__Impl rule__ElseIfThenExpCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__ElseIfThenExpCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ElseIfThenExpCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ElseIfThenExpCS__Group__2" |
| |
| |
| // $ANTLR start "rule__ElseIfThenExpCS__Group__2__Impl" |
| // InternalEssentialOCL.g:10483:1: rule__ElseIfThenExpCS__Group__2__Impl : ( 'then' ) ; |
| public final void rule__ElseIfThenExpCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10487:1: ( ( 'then' ) ) |
| // InternalEssentialOCL.g:10488:1: ( 'then' ) |
| { |
| // InternalEssentialOCL.g:10488:1: ( 'then' ) |
| // InternalEssentialOCL.g:10489:1: 'then' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getElseIfThenExpCSAccess().getThenKeyword_2()); |
| } |
| match(input,75,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getElseIfThenExpCSAccess().getThenKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ElseIfThenExpCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__ElseIfThenExpCS__Group__3" |
| // InternalEssentialOCL.g:10502:1: rule__ElseIfThenExpCS__Group__3 : rule__ElseIfThenExpCS__Group__3__Impl ; |
| public final void rule__ElseIfThenExpCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10506:1: ( rule__ElseIfThenExpCS__Group__3__Impl ) |
| // InternalEssentialOCL.g:10507:2: rule__ElseIfThenExpCS__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ElseIfThenExpCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ElseIfThenExpCS__Group__3" |
| |
| |
| // $ANTLR start "rule__ElseIfThenExpCS__Group__3__Impl" |
| // InternalEssentialOCL.g:10513:1: rule__ElseIfThenExpCS__Group__3__Impl : ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) ) ; |
| public final void rule__ElseIfThenExpCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10517:1: ( ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) ) ) |
| // InternalEssentialOCL.g:10518:1: ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) ) |
| { |
| // InternalEssentialOCL.g:10518:1: ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) ) |
| // InternalEssentialOCL.g:10519:1: ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionAssignment_3()); |
| } |
| // InternalEssentialOCL.g:10520:1: ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) |
| // InternalEssentialOCL.g:10520:2: rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ElseIfThenExpCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group__0" |
| // InternalEssentialOCL.g:10538:1: rule__LetExpCS__Group__0 : rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1 ; |
| public final void rule__LetExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10542:1: ( rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1 ) |
| // InternalEssentialOCL.g:10543:2: rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__LetExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:10550:1: rule__LetExpCS__Group__0__Impl : ( 'let' ) ; |
| public final void rule__LetExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10554:1: ( ( 'let' ) ) |
| // InternalEssentialOCL.g:10555:1: ( 'let' ) |
| { |
| // InternalEssentialOCL.g:10555:1: ( 'let' ) |
| // InternalEssentialOCL.g:10556:1: 'let' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSAccess().getLetKeyword_0()); |
| } |
| match(input,79,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSAccess().getLetKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group__1" |
| // InternalEssentialOCL.g:10569:1: rule__LetExpCS__Group__1 : rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2 ; |
| public final void rule__LetExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10573:1: ( rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2 ) |
| // InternalEssentialOCL.g:10574:2: rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_48); |
| rule__LetExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetExpCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:10581:1: rule__LetExpCS__Group__1__Impl : ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) ) ; |
| public final void rule__LetExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10585:1: ( ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) ) ) |
| // InternalEssentialOCL.g:10586:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) ) |
| { |
| // InternalEssentialOCL.g:10586:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) ) |
| // InternalEssentialOCL.g:10587:1: ( rule__LetExpCS__OwnedVariablesAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_1()); |
| } |
| // InternalEssentialOCL.g:10588:1: ( rule__LetExpCS__OwnedVariablesAssignment_1 ) |
| // InternalEssentialOCL.g:10588:2: rule__LetExpCS__OwnedVariablesAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetExpCS__OwnedVariablesAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group__2" |
| // InternalEssentialOCL.g:10598:1: rule__LetExpCS__Group__2 : rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3 ; |
| public final void rule__LetExpCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10602:1: ( rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3 ) |
| // InternalEssentialOCL.g:10603:2: rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_48); |
| rule__LetExpCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetExpCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group__2" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group__2__Impl" |
| // InternalEssentialOCL.g:10610:1: rule__LetExpCS__Group__2__Impl : ( ( rule__LetExpCS__Group_2__0 )* ) ; |
| public final void rule__LetExpCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10614:1: ( ( ( rule__LetExpCS__Group_2__0 )* ) ) |
| // InternalEssentialOCL.g:10615:1: ( ( rule__LetExpCS__Group_2__0 )* ) |
| { |
| // InternalEssentialOCL.g:10615:1: ( ( rule__LetExpCS__Group_2__0 )* ) |
| // InternalEssentialOCL.g:10616:1: ( rule__LetExpCS__Group_2__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSAccess().getGroup_2()); |
| } |
| // InternalEssentialOCL.g:10617:1: ( rule__LetExpCS__Group_2__0 )* |
| loop87: |
| do { |
| int alt87=2; |
| int LA87_0 = input.LA(1); |
| |
| if ( (LA87_0==61) ) { |
| alt87=1; |
| } |
| |
| |
| switch (alt87) { |
| case 1 : |
| // InternalEssentialOCL.g:10617:2: rule__LetExpCS__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_11); |
| rule__LetExpCS__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop87; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group__3" |
| // InternalEssentialOCL.g:10627:1: rule__LetExpCS__Group__3 : rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4 ; |
| public final void rule__LetExpCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10631:1: ( rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4 ) |
| // InternalEssentialOCL.g:10632:2: rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__LetExpCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetExpCS__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group__3" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group__3__Impl" |
| // InternalEssentialOCL.g:10639:1: rule__LetExpCS__Group__3__Impl : ( 'in' ) ; |
| public final void rule__LetExpCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10643:1: ( ( 'in' ) ) |
| // InternalEssentialOCL.g:10644:1: ( 'in' ) |
| { |
| // InternalEssentialOCL.g:10644:1: ( 'in' ) |
| // InternalEssentialOCL.g:10645:1: 'in' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSAccess().getInKeyword_3()); |
| } |
| match(input,73,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSAccess().getInKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group__4" |
| // InternalEssentialOCL.g:10658:1: rule__LetExpCS__Group__4 : rule__LetExpCS__Group__4__Impl ; |
| public final void rule__LetExpCS__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10662:1: ( rule__LetExpCS__Group__4__Impl ) |
| // InternalEssentialOCL.g:10663:2: rule__LetExpCS__Group__4__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetExpCS__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group__4" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group__4__Impl" |
| // InternalEssentialOCL.g:10669:1: rule__LetExpCS__Group__4__Impl : ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) ) ; |
| public final void rule__LetExpCS__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10673:1: ( ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) ) ) |
| // InternalEssentialOCL.g:10674:1: ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) ) |
| { |
| // InternalEssentialOCL.g:10674:1: ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) ) |
| // InternalEssentialOCL.g:10675:1: ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSAccess().getOwnedInExpressionAssignment_4()); |
| } |
| // InternalEssentialOCL.g:10676:1: ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) |
| // InternalEssentialOCL.g:10676:2: rule__LetExpCS__OwnedInExpressionAssignment_4 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetExpCS__OwnedInExpressionAssignment_4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSAccess().getOwnedInExpressionAssignment_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group_2__0" |
| // InternalEssentialOCL.g:10696:1: rule__LetExpCS__Group_2__0 : rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1 ; |
| public final void rule__LetExpCS__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10700:1: ( rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1 ) |
| // InternalEssentialOCL.g:10701:2: rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__LetExpCS__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetExpCS__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group_2__0" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group_2__0__Impl" |
| // InternalEssentialOCL.g:10708:1: rule__LetExpCS__Group_2__0__Impl : ( ',' ) ; |
| public final void rule__LetExpCS__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10712:1: ( ( ',' ) ) |
| // InternalEssentialOCL.g:10713:1: ( ',' ) |
| { |
| // InternalEssentialOCL.g:10713:1: ( ',' ) |
| // InternalEssentialOCL.g:10714:1: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSAccess().getCommaKeyword_2_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSAccess().getCommaKeyword_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group_2__1" |
| // InternalEssentialOCL.g:10727:1: rule__LetExpCS__Group_2__1 : rule__LetExpCS__Group_2__1__Impl ; |
| public final void rule__LetExpCS__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10731:1: ( rule__LetExpCS__Group_2__1__Impl ) |
| // InternalEssentialOCL.g:10732:2: rule__LetExpCS__Group_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetExpCS__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__LetExpCS__Group_2__1" |
| |
| |
| // $ANTLR start "rule__LetExpCS__Group_2__1__Impl" |
| // InternalEssentialOCL.g:10738:1: rule__LetExpCS__Group_2__1__Impl : ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) ) ; |
| public final void rule__LetExpCS__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10742:1: ( ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) ) ) |
| // InternalEssentialOCL.g:10743:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:10743:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) ) |
| // InternalEssentialOCL.g:10744:1: ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_2_1()); |
| } |
| // InternalEssentialOCL.g:10745:1: ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) |
| // InternalEssentialOCL.g:10745:2: rule__LetExpCS__OwnedVariablesAssignment_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetExpCS__OwnedVariablesAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group__0" |
| // InternalEssentialOCL.g:10759:1: rule__LetVariableCS__Group__0 : rule__LetVariableCS__Group__0__Impl rule__LetVariableCS__Group__1 ; |
| public final void rule__LetVariableCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10763:1: ( rule__LetVariableCS__Group__0__Impl rule__LetVariableCS__Group__1 ) |
| // InternalEssentialOCL.g:10764:2: rule__LetVariableCS__Group__0__Impl rule__LetVariableCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_49); |
| rule__LetVariableCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group__0" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group__0__Impl" |
| // InternalEssentialOCL.g:10771:1: rule__LetVariableCS__Group__0__Impl : ( ( rule__LetVariableCS__NameAssignment_0 ) ) ; |
| public final void rule__LetVariableCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10775:1: ( ( ( rule__LetVariableCS__NameAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:10776:1: ( ( rule__LetVariableCS__NameAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:10776:1: ( ( rule__LetVariableCS__NameAssignment_0 ) ) |
| // InternalEssentialOCL.g:10777:1: ( rule__LetVariableCS__NameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:10778:1: ( rule__LetVariableCS__NameAssignment_0 ) |
| // InternalEssentialOCL.g:10778:2: rule__LetVariableCS__NameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__NameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group__1" |
| // InternalEssentialOCL.g:10788:1: rule__LetVariableCS__Group__1 : rule__LetVariableCS__Group__1__Impl rule__LetVariableCS__Group__2 ; |
| public final void rule__LetVariableCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10792:1: ( rule__LetVariableCS__Group__1__Impl rule__LetVariableCS__Group__2 ) |
| // InternalEssentialOCL.g:10793:2: rule__LetVariableCS__Group__1__Impl rule__LetVariableCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_49); |
| rule__LetVariableCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group__1" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group__1__Impl" |
| // InternalEssentialOCL.g:10800:1: rule__LetVariableCS__Group__1__Impl : ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? ) ; |
| public final void rule__LetVariableCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10804:1: ( ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? ) ) |
| // InternalEssentialOCL.g:10805:1: ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? ) |
| { |
| // InternalEssentialOCL.g:10805:1: ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? ) |
| // InternalEssentialOCL.g:10806:1: ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseAssignment_1()); |
| } |
| // InternalEssentialOCL.g:10807:1: ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? |
| int alt88=2; |
| int LA88_0 = input.LA(1); |
| |
| if ( (LA88_0==59) ) { |
| alt88=1; |
| } |
| switch (alt88) { |
| case 1 : |
| // InternalEssentialOCL.g:10807:2: rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group__2" |
| // InternalEssentialOCL.g:10817:1: rule__LetVariableCS__Group__2 : rule__LetVariableCS__Group__2__Impl rule__LetVariableCS__Group__3 ; |
| public final void rule__LetVariableCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10821:1: ( rule__LetVariableCS__Group__2__Impl rule__LetVariableCS__Group__3 ) |
| // InternalEssentialOCL.g:10822:2: rule__LetVariableCS__Group__2__Impl rule__LetVariableCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_49); |
| rule__LetVariableCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group__2" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group__2__Impl" |
| // InternalEssentialOCL.g:10829:1: rule__LetVariableCS__Group__2__Impl : ( ( rule__LetVariableCS__Group_2__0 )? ) ; |
| public final void rule__LetVariableCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10833:1: ( ( ( rule__LetVariableCS__Group_2__0 )? ) ) |
| // InternalEssentialOCL.g:10834:1: ( ( rule__LetVariableCS__Group_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:10834:1: ( ( rule__LetVariableCS__Group_2__0 )? ) |
| // InternalEssentialOCL.g:10835:1: ( rule__LetVariableCS__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getGroup_2()); |
| } |
| // InternalEssentialOCL.g:10836:1: ( rule__LetVariableCS__Group_2__0 )? |
| int alt89=2; |
| int LA89_0 = input.LA(1); |
| |
| if ( (LA89_0==62) ) { |
| alt89=1; |
| } |
| switch (alt89) { |
| case 1 : |
| // InternalEssentialOCL.g:10836:2: rule__LetVariableCS__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group__3" |
| // InternalEssentialOCL.g:10846:1: rule__LetVariableCS__Group__3 : rule__LetVariableCS__Group__3__Impl rule__LetVariableCS__Group__4 ; |
| public final void rule__LetVariableCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10850:1: ( rule__LetVariableCS__Group__3__Impl rule__LetVariableCS__Group__4 ) |
| // InternalEssentialOCL.g:10851:2: rule__LetVariableCS__Group__3__Impl rule__LetVariableCS__Group__4 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__LetVariableCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group__3" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group__3__Impl" |
| // InternalEssentialOCL.g:10858:1: rule__LetVariableCS__Group__3__Impl : ( '=' ) ; |
| public final void rule__LetVariableCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10862:1: ( ( '=' ) ) |
| // InternalEssentialOCL.g:10863:1: ( '=' ) |
| { |
| // InternalEssentialOCL.g:10863:1: ( '=' ) |
| // InternalEssentialOCL.g:10864:1: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getEqualsSignKeyword_3()); |
| } |
| match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getEqualsSignKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group__4" |
| // InternalEssentialOCL.g:10877:1: rule__LetVariableCS__Group__4 : rule__LetVariableCS__Group__4__Impl ; |
| public final void rule__LetVariableCS__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10881:1: ( rule__LetVariableCS__Group__4__Impl ) |
| // InternalEssentialOCL.g:10882:2: rule__LetVariableCS__Group__4__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group__4" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group__4__Impl" |
| // InternalEssentialOCL.g:10888:1: rule__LetVariableCS__Group__4__Impl : ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) ) ; |
| public final void rule__LetVariableCS__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10892:1: ( ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) ) ) |
| // InternalEssentialOCL.g:10893:1: ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) ) |
| { |
| // InternalEssentialOCL.g:10893:1: ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) ) |
| // InternalEssentialOCL.g:10894:1: ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionAssignment_4()); |
| } |
| // InternalEssentialOCL.g:10895:1: ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) |
| // InternalEssentialOCL.g:10895:2: rule__LetVariableCS__OwnedInitExpressionAssignment_4 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__OwnedInitExpressionAssignment_4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionAssignment_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group_2__0" |
| // InternalEssentialOCL.g:10915:1: rule__LetVariableCS__Group_2__0 : rule__LetVariableCS__Group_2__0__Impl rule__LetVariableCS__Group_2__1 ; |
| public final void rule__LetVariableCS__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10919:1: ( rule__LetVariableCS__Group_2__0__Impl rule__LetVariableCS__Group_2__1 ) |
| // InternalEssentialOCL.g:10920:2: rule__LetVariableCS__Group_2__0__Impl rule__LetVariableCS__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__LetVariableCS__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group_2__0" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group_2__0__Impl" |
| // InternalEssentialOCL.g:10927:1: rule__LetVariableCS__Group_2__0__Impl : ( ':' ) ; |
| public final void rule__LetVariableCS__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10931:1: ( ( ':' ) ) |
| // InternalEssentialOCL.g:10932:1: ( ':' ) |
| { |
| // InternalEssentialOCL.g:10932:1: ( ':' ) |
| // InternalEssentialOCL.g:10933:1: ':' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getColonKeyword_2_0()); |
| } |
| match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getColonKeyword_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group_2__1" |
| // InternalEssentialOCL.g:10946:1: rule__LetVariableCS__Group_2__1 : rule__LetVariableCS__Group_2__1__Impl ; |
| public final void rule__LetVariableCS__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10950:1: ( rule__LetVariableCS__Group_2__1__Impl ) |
| // InternalEssentialOCL.g:10951:2: rule__LetVariableCS__Group_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__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__LetVariableCS__Group_2__1" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__Group_2__1__Impl" |
| // InternalEssentialOCL.g:10957:1: rule__LetVariableCS__Group_2__1__Impl : ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) ) ; |
| public final void rule__LetVariableCS__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10961:1: ( ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) ) ) |
| // InternalEssentialOCL.g:10962:1: ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:10962:1: ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) ) |
| // InternalEssentialOCL.g:10963:1: ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getOwnedTypeAssignment_2_1()); |
| } |
| // InternalEssentialOCL.g:10964:1: ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) |
| // InternalEssentialOCL.g:10964:2: rule__LetVariableCS__OwnedTypeAssignment_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__LetVariableCS__OwnedTypeAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getOwnedTypeAssignment_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__NestedExpCS__Group__0" |
| // InternalEssentialOCL.g:10978:1: rule__NestedExpCS__Group__0 : rule__NestedExpCS__Group__0__Impl rule__NestedExpCS__Group__1 ; |
| public final void rule__NestedExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10982:1: ( rule__NestedExpCS__Group__0__Impl rule__NestedExpCS__Group__1 ) |
| // InternalEssentialOCL.g:10983:2: rule__NestedExpCS__Group__0__Impl rule__NestedExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_18); |
| rule__NestedExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NestedExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__NestedExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:10990:1: rule__NestedExpCS__Group__0__Impl : ( '(' ) ; |
| public final void rule__NestedExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:10994:1: ( ( '(' ) ) |
| // InternalEssentialOCL.g:10995:1: ( '(' ) |
| { |
| // InternalEssentialOCL.g:10995:1: ( '(' ) |
| // InternalEssentialOCL.g:10996:1: '(' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedExpCSAccess().getLeftParenthesisKeyword_0()); |
| } |
| match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedExpCSAccess().getLeftParenthesisKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__NestedExpCS__Group__1" |
| // InternalEssentialOCL.g:11009:1: rule__NestedExpCS__Group__1 : rule__NestedExpCS__Group__1__Impl rule__NestedExpCS__Group__2 ; |
| public final void rule__NestedExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11013:1: ( rule__NestedExpCS__Group__1__Impl rule__NestedExpCS__Group__2 ) |
| // InternalEssentialOCL.g:11014:2: rule__NestedExpCS__Group__1__Impl rule__NestedExpCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_9); |
| rule__NestedExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NestedExpCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__NestedExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:11021:1: rule__NestedExpCS__Group__1__Impl : ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) ) ; |
| public final void rule__NestedExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11025:1: ( ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) ) ) |
| // InternalEssentialOCL.g:11026:1: ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) ) |
| { |
| // InternalEssentialOCL.g:11026:1: ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) ) |
| // InternalEssentialOCL.g:11027:1: ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedExpCSAccess().getOwnedExpressionAssignment_1()); |
| } |
| // InternalEssentialOCL.g:11028:1: ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) |
| // InternalEssentialOCL.g:11028:2: rule__NestedExpCS__OwnedExpressionAssignment_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NestedExpCS__OwnedExpressionAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedExpCSAccess().getOwnedExpressionAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__NestedExpCS__Group__2" |
| // InternalEssentialOCL.g:11038:1: rule__NestedExpCS__Group__2 : rule__NestedExpCS__Group__2__Impl ; |
| public final void rule__NestedExpCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11042:1: ( rule__NestedExpCS__Group__2__Impl ) |
| // InternalEssentialOCL.g:11043:2: rule__NestedExpCS__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NestedExpCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedExpCS__Group__2" |
| |
| |
| // $ANTLR start "rule__NestedExpCS__Group__2__Impl" |
| // InternalEssentialOCL.g:11049:1: rule__NestedExpCS__Group__2__Impl : ( ')' ) ; |
| public final void rule__NestedExpCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11053:1: ( ( ')' ) ) |
| // InternalEssentialOCL.g:11054:1: ( ')' ) |
| { |
| // InternalEssentialOCL.g:11054:1: ( ')' ) |
| // InternalEssentialOCL.g:11055:1: ')' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedExpCSAccess().getRightParenthesisKeyword_2()); |
| } |
| match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedExpCSAccess().getRightParenthesisKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedExpCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__SelfExpCS__Group__0" |
| // InternalEssentialOCL.g:11074:1: rule__SelfExpCS__Group__0 : rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1 ; |
| public final void rule__SelfExpCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11078:1: ( rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1 ) |
| // InternalEssentialOCL.g:11079:2: rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_50); |
| rule__SelfExpCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SelfExpCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SelfExpCS__Group__0" |
| |
| |
| // $ANTLR start "rule__SelfExpCS__Group__0__Impl" |
| // InternalEssentialOCL.g:11086:1: rule__SelfExpCS__Group__0__Impl : ( () ) ; |
| public final void rule__SelfExpCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11090:1: ( ( () ) ) |
| // InternalEssentialOCL.g:11091:1: ( () ) |
| { |
| // InternalEssentialOCL.g:11091:1: ( () ) |
| // InternalEssentialOCL.g:11092:1: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSelfExpCSAccess().getSelfExpCSAction_0()); |
| } |
| // InternalEssentialOCL.g:11093:1: () |
| // InternalEssentialOCL.g:11095:1: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSelfExpCSAccess().getSelfExpCSAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SelfExpCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__SelfExpCS__Group__1" |
| // InternalEssentialOCL.g:11105:1: rule__SelfExpCS__Group__1 : rule__SelfExpCS__Group__1__Impl ; |
| public final void rule__SelfExpCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11109:1: ( rule__SelfExpCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:11110:2: rule__SelfExpCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__SelfExpCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SelfExpCS__Group__1" |
| |
| |
| // $ANTLR start "rule__SelfExpCS__Group__1__Impl" |
| // InternalEssentialOCL.g:11116:1: rule__SelfExpCS__Group__1__Impl : ( 'self' ) ; |
| public final void rule__SelfExpCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11120:1: ( ( 'self' ) ) |
| // InternalEssentialOCL.g:11121:1: ( 'self' ) |
| { |
| // InternalEssentialOCL.g:11121:1: ( 'self' ) |
| // InternalEssentialOCL.g:11122:1: 'self' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSelfExpCSAccess().getSelfKeyword_1()); |
| } |
| match(input,80,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSelfExpCSAccess().getSelfKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SelfExpCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicityBoundsCS__Group__0" |
| // InternalEssentialOCL.g:11139:1: rule__MultiplicityBoundsCS__Group__0 : rule__MultiplicityBoundsCS__Group__0__Impl rule__MultiplicityBoundsCS__Group__1 ; |
| public final void rule__MultiplicityBoundsCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11143:1: ( rule__MultiplicityBoundsCS__Group__0__Impl rule__MultiplicityBoundsCS__Group__1 ) |
| // InternalEssentialOCL.g:11144:2: rule__MultiplicityBoundsCS__Group__0__Impl rule__MultiplicityBoundsCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_17); |
| rule__MultiplicityBoundsCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityBoundsCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityBoundsCS__Group__0" |
| |
| |
| // $ANTLR start "rule__MultiplicityBoundsCS__Group__0__Impl" |
| // InternalEssentialOCL.g:11151:1: rule__MultiplicityBoundsCS__Group__0__Impl : ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) ) ; |
| public final void rule__MultiplicityBoundsCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11155:1: ( ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:11156:1: ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:11156:1: ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) ) |
| // InternalEssentialOCL.g:11157:1: ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundAssignment_0()); |
| } |
| // InternalEssentialOCL.g:11158:1: ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) |
| // InternalEssentialOCL.g:11158:2: rule__MultiplicityBoundsCS__LowerBoundAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityBoundsCS__LowerBoundAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityBoundsCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicityBoundsCS__Group__1" |
| // InternalEssentialOCL.g:11168:1: rule__MultiplicityBoundsCS__Group__1 : rule__MultiplicityBoundsCS__Group__1__Impl ; |
| public final void rule__MultiplicityBoundsCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11172:1: ( rule__MultiplicityBoundsCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:11173:2: rule__MultiplicityBoundsCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityBoundsCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityBoundsCS__Group__1" |
| |
| |
| // $ANTLR start "rule__MultiplicityBoundsCS__Group__1__Impl" |
| // InternalEssentialOCL.g:11179:1: rule__MultiplicityBoundsCS__Group__1__Impl : ( ( rule__MultiplicityBoundsCS__Group_1__0 )? ) ; |
| public final void rule__MultiplicityBoundsCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11183:1: ( ( ( rule__MultiplicityBoundsCS__Group_1__0 )? ) ) |
| // InternalEssentialOCL.g:11184:1: ( ( rule__MultiplicityBoundsCS__Group_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:11184:1: ( ( rule__MultiplicityBoundsCS__Group_1__0 )? ) |
| // InternalEssentialOCL.g:11185:1: ( rule__MultiplicityBoundsCS__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityBoundsCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:11186:1: ( rule__MultiplicityBoundsCS__Group_1__0 )? |
| int alt90=2; |
| int LA90_0 = input.LA(1); |
| |
| if ( (LA90_0==65) ) { |
| alt90=1; |
| } |
| switch (alt90) { |
| case 1 : |
| // InternalEssentialOCL.g:11186:2: rule__MultiplicityBoundsCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityBoundsCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityBoundsCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityBoundsCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__0" |
| // InternalEssentialOCL.g:11200:1: rule__MultiplicityBoundsCS__Group_1__0 : rule__MultiplicityBoundsCS__Group_1__0__Impl rule__MultiplicityBoundsCS__Group_1__1 ; |
| public final void rule__MultiplicityBoundsCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11204:1: ( rule__MultiplicityBoundsCS__Group_1__0__Impl rule__MultiplicityBoundsCS__Group_1__1 ) |
| // InternalEssentialOCL.g:11205:2: rule__MultiplicityBoundsCS__Group_1__0__Impl rule__MultiplicityBoundsCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_51); |
| rule__MultiplicityBoundsCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityBoundsCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityBoundsCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:11212:1: rule__MultiplicityBoundsCS__Group_1__0__Impl : ( '..' ) ; |
| public final void rule__MultiplicityBoundsCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11216:1: ( ( '..' ) ) |
| // InternalEssentialOCL.g:11217:1: ( '..' ) |
| { |
| // InternalEssentialOCL.g:11217:1: ( '..' ) |
| // InternalEssentialOCL.g:11218:1: '..' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityBoundsCSAccess().getFullStopFullStopKeyword_1_0()); |
| } |
| match(input,65,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityBoundsCSAccess().getFullStopFullStopKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityBoundsCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__1" |
| // InternalEssentialOCL.g:11231:1: rule__MultiplicityBoundsCS__Group_1__1 : rule__MultiplicityBoundsCS__Group_1__1__Impl ; |
| public final void rule__MultiplicityBoundsCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11235:1: ( rule__MultiplicityBoundsCS__Group_1__1__Impl ) |
| // InternalEssentialOCL.g:11236:2: rule__MultiplicityBoundsCS__Group_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityBoundsCS__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__MultiplicityBoundsCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:11242:1: rule__MultiplicityBoundsCS__Group_1__1__Impl : ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) ) ; |
| public final void rule__MultiplicityBoundsCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11246:1: ( ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) ) ) |
| // InternalEssentialOCL.g:11247:1: ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:11247:1: ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) ) |
| // InternalEssentialOCL.g:11248:1: ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundAssignment_1_1()); |
| } |
| // InternalEssentialOCL.g:11249:1: ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) |
| // InternalEssentialOCL.g:11249:2: rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityBoundsCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicityCS__Group__0" |
| // InternalEssentialOCL.g:11263:1: rule__MultiplicityCS__Group__0 : rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1 ; |
| public final void rule__MultiplicityCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11267:1: ( rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1 ) |
| // InternalEssentialOCL.g:11268:2: rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_52); |
| rule__MultiplicityCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityCS__Group__0" |
| |
| |
| // $ANTLR start "rule__MultiplicityCS__Group__0__Impl" |
| // InternalEssentialOCL.g:11275:1: rule__MultiplicityCS__Group__0__Impl : ( '[' ) ; |
| public final void rule__MultiplicityCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11279:1: ( ( '[' ) ) |
| // InternalEssentialOCL.g:11280:1: ( '[' ) |
| { |
| // InternalEssentialOCL.g:11280:1: ( '[' ) |
| // InternalEssentialOCL.g:11281:1: '[' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSAccess().getLeftSquareBracketKeyword_0()); |
| } |
| match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSAccess().getLeftSquareBracketKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicityCS__Group__1" |
| // InternalEssentialOCL.g:11294:1: rule__MultiplicityCS__Group__1 : rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2 ; |
| public final void rule__MultiplicityCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11298:1: ( rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2 ) |
| // InternalEssentialOCL.g:11299:2: rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_53); |
| rule__MultiplicityCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityCS__Group__1" |
| |
| |
| // $ANTLR start "rule__MultiplicityCS__Group__1__Impl" |
| // InternalEssentialOCL.g:11306:1: rule__MultiplicityCS__Group__1__Impl : ( ( rule__MultiplicityCS__Alternatives_1 ) ) ; |
| public final void rule__MultiplicityCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11310:1: ( ( ( rule__MultiplicityCS__Alternatives_1 ) ) ) |
| // InternalEssentialOCL.g:11311:1: ( ( rule__MultiplicityCS__Alternatives_1 ) ) |
| { |
| // InternalEssentialOCL.g:11311:1: ( ( rule__MultiplicityCS__Alternatives_1 ) ) |
| // InternalEssentialOCL.g:11312:1: ( rule__MultiplicityCS__Alternatives_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSAccess().getAlternatives_1()); |
| } |
| // InternalEssentialOCL.g:11313:1: ( rule__MultiplicityCS__Alternatives_1 ) |
| // InternalEssentialOCL.g:11313:2: rule__MultiplicityCS__Alternatives_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityCS__Alternatives_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSAccess().getAlternatives_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicityCS__Group__2" |
| // InternalEssentialOCL.g:11323:1: rule__MultiplicityCS__Group__2 : rule__MultiplicityCS__Group__2__Impl rule__MultiplicityCS__Group__3 ; |
| public final void rule__MultiplicityCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11327:1: ( rule__MultiplicityCS__Group__2__Impl rule__MultiplicityCS__Group__3 ) |
| // InternalEssentialOCL.g:11328:2: rule__MultiplicityCS__Group__2__Impl rule__MultiplicityCS__Group__3 |
| { |
| pushFollow(FollowSets000.FOLLOW_53); |
| rule__MultiplicityCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityCS__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityCS__Group__2" |
| |
| |
| // $ANTLR start "rule__MultiplicityCS__Group__2__Impl" |
| // InternalEssentialOCL.g:11335:1: rule__MultiplicityCS__Group__2__Impl : ( ( rule__MultiplicityCS__Alternatives_2 )? ) ; |
| public final void rule__MultiplicityCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11339:1: ( ( ( rule__MultiplicityCS__Alternatives_2 )? ) ) |
| // InternalEssentialOCL.g:11340:1: ( ( rule__MultiplicityCS__Alternatives_2 )? ) |
| { |
| // InternalEssentialOCL.g:11340:1: ( ( rule__MultiplicityCS__Alternatives_2 )? ) |
| // InternalEssentialOCL.g:11341:1: ( rule__MultiplicityCS__Alternatives_2 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSAccess().getAlternatives_2()); |
| } |
| // InternalEssentialOCL.g:11342:1: ( rule__MultiplicityCS__Alternatives_2 )? |
| int alt91=2; |
| int LA91_0 = input.LA(1); |
| |
| if ( (LA91_0==57||LA91_0==89) ) { |
| alt91=1; |
| } |
| switch (alt91) { |
| case 1 : |
| // InternalEssentialOCL.g:11342:2: rule__MultiplicityCS__Alternatives_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityCS__Alternatives_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSAccess().getAlternatives_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__MultiplicityCS__Group__3" |
| // InternalEssentialOCL.g:11352:1: rule__MultiplicityCS__Group__3 : rule__MultiplicityCS__Group__3__Impl ; |
| public final void rule__MultiplicityCS__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11356:1: ( rule__MultiplicityCS__Group__3__Impl ) |
| // InternalEssentialOCL.g:11357:2: rule__MultiplicityCS__Group__3__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityCS__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityCS__Group__3" |
| |
| |
| // $ANTLR start "rule__MultiplicityCS__Group__3__Impl" |
| // InternalEssentialOCL.g:11363:1: rule__MultiplicityCS__Group__3__Impl : ( ']' ) ; |
| public final void rule__MultiplicityCS__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11367:1: ( ( ']' ) ) |
| // InternalEssentialOCL.g:11368:1: ( ']' ) |
| { |
| // InternalEssentialOCL.g:11368:1: ( ']' ) |
| // InternalEssentialOCL.g:11369:1: ']' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSAccess().getRightSquareBracketKeyword_3()); |
| } |
| match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSAccess().getRightSquareBracketKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityCS__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__PathNameCS__Group__0" |
| // InternalEssentialOCL.g:11390:1: rule__PathNameCS__Group__0 : rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1 ; |
| public final void rule__PathNameCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11394:1: ( rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1 ) |
| // InternalEssentialOCL.g:11395:2: rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_54); |
| rule__PathNameCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PathNameCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PathNameCS__Group__0" |
| |
| |
| // $ANTLR start "rule__PathNameCS__Group__0__Impl" |
| // InternalEssentialOCL.g:11402:1: rule__PathNameCS__Group__0__Impl : ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) ) ; |
| public final void rule__PathNameCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11406:1: ( ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:11407:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:11407:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) ) |
| // InternalEssentialOCL.g:11408:1: ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_0()); |
| } |
| // InternalEssentialOCL.g:11409:1: ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) |
| // InternalEssentialOCL.g:11409:2: rule__PathNameCS__OwnedPathElementsAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PathNameCS__OwnedPathElementsAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PathNameCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PathNameCS__Group__1" |
| // InternalEssentialOCL.g:11419:1: rule__PathNameCS__Group__1 : rule__PathNameCS__Group__1__Impl ; |
| public final void rule__PathNameCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11423:1: ( rule__PathNameCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:11424:2: rule__PathNameCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PathNameCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PathNameCS__Group__1" |
| |
| |
| // $ANTLR start "rule__PathNameCS__Group__1__Impl" |
| // InternalEssentialOCL.g:11430:1: rule__PathNameCS__Group__1__Impl : ( ( rule__PathNameCS__Group_1__0 )* ) ; |
| public final void rule__PathNameCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11434:1: ( ( ( rule__PathNameCS__Group_1__0 )* ) ) |
| // InternalEssentialOCL.g:11435:1: ( ( rule__PathNameCS__Group_1__0 )* ) |
| { |
| // InternalEssentialOCL.g:11435:1: ( ( rule__PathNameCS__Group_1__0 )* ) |
| // InternalEssentialOCL.g:11436:1: ( rule__PathNameCS__Group_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPathNameCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:11437:1: ( rule__PathNameCS__Group_1__0 )* |
| loop92: |
| do { |
| int alt92=2; |
| int LA92_0 = input.LA(1); |
| |
| if ( (LA92_0==81) ) { |
| alt92=1; |
| } |
| |
| |
| switch (alt92) { |
| case 1 : |
| // InternalEssentialOCL.g:11437:2: rule__PathNameCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_55); |
| rule__PathNameCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop92; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPathNameCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PathNameCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PathNameCS__Group_1__0" |
| // InternalEssentialOCL.g:11451:1: rule__PathNameCS__Group_1__0 : rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1 ; |
| public final void rule__PathNameCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11455:1: ( rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1 ) |
| // InternalEssentialOCL.g:11456:2: rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_6); |
| rule__PathNameCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PathNameCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PathNameCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__PathNameCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:11463:1: rule__PathNameCS__Group_1__0__Impl : ( '::' ) ; |
| public final void rule__PathNameCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11467:1: ( ( '::' ) ) |
| // InternalEssentialOCL.g:11468:1: ( '::' ) |
| { |
| // InternalEssentialOCL.g:11468:1: ( '::' ) |
| // InternalEssentialOCL.g:11469:1: '::' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPathNameCSAccess().getColonColonKeyword_1_0()); |
| } |
| match(input,81,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPathNameCSAccess().getColonColonKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PathNameCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__PathNameCS__Group_1__1" |
| // InternalEssentialOCL.g:11482:1: rule__PathNameCS__Group_1__1 : rule__PathNameCS__Group_1__1__Impl ; |
| public final void rule__PathNameCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11486:1: ( rule__PathNameCS__Group_1__1__Impl ) |
| // InternalEssentialOCL.g:11487:2: rule__PathNameCS__Group_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PathNameCS__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__PathNameCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__PathNameCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:11493:1: rule__PathNameCS__Group_1__1__Impl : ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) ) ; |
| public final void rule__PathNameCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11497:1: ( ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) ) ) |
| // InternalEssentialOCL.g:11498:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:11498:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) ) |
| // InternalEssentialOCL.g:11499:1: ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_1_1()); |
| } |
| // InternalEssentialOCL.g:11500:1: ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) |
| // InternalEssentialOCL.g:11500:2: rule__PathNameCS__OwnedPathElementsAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__PathNameCS__OwnedPathElementsAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PathNameCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__Group__0" |
| // InternalEssentialOCL.g:11516:1: rule__TemplateBindingCS__Group__0 : rule__TemplateBindingCS__Group__0__Impl rule__TemplateBindingCS__Group__1 ; |
| public final void rule__TemplateBindingCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11520:1: ( rule__TemplateBindingCS__Group__0__Impl rule__TemplateBindingCS__Group__1 ) |
| // InternalEssentialOCL.g:11521:2: rule__TemplateBindingCS__Group__0__Impl rule__TemplateBindingCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_56); |
| rule__TemplateBindingCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TemplateBindingCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__Group__0" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__Group__0__Impl" |
| // InternalEssentialOCL.g:11528:1: rule__TemplateBindingCS__Group__0__Impl : ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) ) ; |
| public final void rule__TemplateBindingCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11532:1: ( ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:11533:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:11533:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) ) |
| // InternalEssentialOCL.g:11534:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_0()); |
| } |
| // InternalEssentialOCL.g:11535:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) |
| // InternalEssentialOCL.g:11535:2: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__Group__1" |
| // InternalEssentialOCL.g:11545:1: rule__TemplateBindingCS__Group__1 : rule__TemplateBindingCS__Group__1__Impl rule__TemplateBindingCS__Group__2 ; |
| public final void rule__TemplateBindingCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11549:1: ( rule__TemplateBindingCS__Group__1__Impl rule__TemplateBindingCS__Group__2 ) |
| // InternalEssentialOCL.g:11550:2: rule__TemplateBindingCS__Group__1__Impl rule__TemplateBindingCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_56); |
| rule__TemplateBindingCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TemplateBindingCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__Group__1" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__Group__1__Impl" |
| // InternalEssentialOCL.g:11557:1: rule__TemplateBindingCS__Group__1__Impl : ( ( rule__TemplateBindingCS__Group_1__0 )* ) ; |
| public final void rule__TemplateBindingCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11561:1: ( ( ( rule__TemplateBindingCS__Group_1__0 )* ) ) |
| // InternalEssentialOCL.g:11562:1: ( ( rule__TemplateBindingCS__Group_1__0 )* ) |
| { |
| // InternalEssentialOCL.g:11562:1: ( ( rule__TemplateBindingCS__Group_1__0 )* ) |
| // InternalEssentialOCL.g:11563:1: ( rule__TemplateBindingCS__Group_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateBindingCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:11564:1: ( rule__TemplateBindingCS__Group_1__0 )* |
| loop93: |
| do { |
| int alt93=2; |
| int LA93_0 = input.LA(1); |
| |
| if ( (LA93_0==61) ) { |
| alt93=1; |
| } |
| |
| |
| switch (alt93) { |
| case 1 : |
| // InternalEssentialOCL.g:11564:2: rule__TemplateBindingCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_11); |
| rule__TemplateBindingCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop93; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateBindingCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__Group__2" |
| // InternalEssentialOCL.g:11574:1: rule__TemplateBindingCS__Group__2 : rule__TemplateBindingCS__Group__2__Impl ; |
| public final void rule__TemplateBindingCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11578:1: ( rule__TemplateBindingCS__Group__2__Impl ) |
| // InternalEssentialOCL.g:11579:2: rule__TemplateBindingCS__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TemplateBindingCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__Group__2" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__Group__2__Impl" |
| // InternalEssentialOCL.g:11585:1: rule__TemplateBindingCS__Group__2__Impl : ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? ) ; |
| public final void rule__TemplateBindingCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11589:1: ( ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? ) ) |
| // InternalEssentialOCL.g:11590:1: ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? ) |
| { |
| // InternalEssentialOCL.g:11590:1: ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? ) |
| // InternalEssentialOCL.g:11591:1: ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityAssignment_2()); |
| } |
| // InternalEssentialOCL.g:11592:1: ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? |
| int alt94=2; |
| int LA94_0 = input.LA(1); |
| |
| if ( (LA94_0==71) ) { |
| alt94=1; |
| } |
| switch (alt94) { |
| case 1 : |
| // InternalEssentialOCL.g:11592:2: rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TemplateBindingCS__OwnedMultiplicityAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__Group_1__0" |
| // InternalEssentialOCL.g:11608:1: rule__TemplateBindingCS__Group_1__0 : rule__TemplateBindingCS__Group_1__0__Impl rule__TemplateBindingCS__Group_1__1 ; |
| public final void rule__TemplateBindingCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11612:1: ( rule__TemplateBindingCS__Group_1__0__Impl rule__TemplateBindingCS__Group_1__1 ) |
| // InternalEssentialOCL.g:11613:2: rule__TemplateBindingCS__Group_1__0__Impl rule__TemplateBindingCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_57); |
| rule__TemplateBindingCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TemplateBindingCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:11620:1: rule__TemplateBindingCS__Group_1__0__Impl : ( ',' ) ; |
| public final void rule__TemplateBindingCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11624:1: ( ( ',' ) ) |
| // InternalEssentialOCL.g:11625:1: ( ',' ) |
| { |
| // InternalEssentialOCL.g:11625:1: ( ',' ) |
| // InternalEssentialOCL.g:11626:1: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateBindingCSAccess().getCommaKeyword_1_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateBindingCSAccess().getCommaKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__Group_1__1" |
| // InternalEssentialOCL.g:11639:1: rule__TemplateBindingCS__Group_1__1 : rule__TemplateBindingCS__Group_1__1__Impl ; |
| public final void rule__TemplateBindingCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11643:1: ( rule__TemplateBindingCS__Group_1__1__Impl ) |
| // InternalEssentialOCL.g:11644:2: rule__TemplateBindingCS__Group_1__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TemplateBindingCS__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__TemplateBindingCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:11650:1: rule__TemplateBindingCS__Group_1__1__Impl : ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) ) ; |
| public final void rule__TemplateBindingCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11654:1: ( ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) ) ) |
| // InternalEssentialOCL.g:11655:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:11655:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) ) |
| // InternalEssentialOCL.g:11656:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_1_1()); |
| } |
| // InternalEssentialOCL.g:11657:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) |
| // InternalEssentialOCL.g:11657:2: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group__0" |
| // InternalEssentialOCL.g:11673:1: rule__TypeParameterCS__Group__0 : rule__TypeParameterCS__Group__0__Impl rule__TypeParameterCS__Group__1 ; |
| public final void rule__TypeParameterCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11677:1: ( rule__TypeParameterCS__Group__0__Impl rule__TypeParameterCS__Group__1 ) |
| // InternalEssentialOCL.g:11678:2: rule__TypeParameterCS__Group__0__Impl rule__TypeParameterCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_58); |
| rule__TypeParameterCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group__0" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group__0__Impl" |
| // InternalEssentialOCL.g:11685:1: rule__TypeParameterCS__Group__0__Impl : ( ( rule__TypeParameterCS__NameAssignment_0 ) ) ; |
| public final void rule__TypeParameterCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11689:1: ( ( ( rule__TypeParameterCS__NameAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:11690:1: ( ( rule__TypeParameterCS__NameAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:11690:1: ( ( rule__TypeParameterCS__NameAssignment_0 ) ) |
| // InternalEssentialOCL.g:11691:1: ( rule__TypeParameterCS__NameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSAccess().getNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:11692:1: ( rule__TypeParameterCS__NameAssignment_0 ) |
| // InternalEssentialOCL.g:11692:2: rule__TypeParameterCS__NameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__NameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSAccess().getNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group__1" |
| // InternalEssentialOCL.g:11702:1: rule__TypeParameterCS__Group__1 : rule__TypeParameterCS__Group__1__Impl ; |
| public final void rule__TypeParameterCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11706:1: ( rule__TypeParameterCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:11707:2: rule__TypeParameterCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group__1" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group__1__Impl" |
| // InternalEssentialOCL.g:11713:1: rule__TypeParameterCS__Group__1__Impl : ( ( rule__TypeParameterCS__Group_1__0 )? ) ; |
| public final void rule__TypeParameterCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11717:1: ( ( ( rule__TypeParameterCS__Group_1__0 )? ) ) |
| // InternalEssentialOCL.g:11718:1: ( ( rule__TypeParameterCS__Group_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:11718:1: ( ( rule__TypeParameterCS__Group_1__0 )? ) |
| // InternalEssentialOCL.g:11719:1: ( rule__TypeParameterCS__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:11720:1: ( rule__TypeParameterCS__Group_1__0 )? |
| int alt95=2; |
| int LA95_0 = input.LA(1); |
| |
| if ( (LA95_0==82) ) { |
| alt95=1; |
| } |
| switch (alt95) { |
| case 1 : |
| // InternalEssentialOCL.g:11720:2: rule__TypeParameterCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group_1__0" |
| // InternalEssentialOCL.g:11734:1: rule__TypeParameterCS__Group_1__0 : rule__TypeParameterCS__Group_1__0__Impl rule__TypeParameterCS__Group_1__1 ; |
| public final void rule__TypeParameterCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11738:1: ( rule__TypeParameterCS__Group_1__0__Impl rule__TypeParameterCS__Group_1__1 ) |
| // InternalEssentialOCL.g:11739:2: rule__TypeParameterCS__Group_1__0__Impl rule__TypeParameterCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__TypeParameterCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:11746:1: rule__TypeParameterCS__Group_1__0__Impl : ( 'extends' ) ; |
| public final void rule__TypeParameterCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11750:1: ( ( 'extends' ) ) |
| // InternalEssentialOCL.g:11751:1: ( 'extends' ) |
| { |
| // InternalEssentialOCL.g:11751:1: ( 'extends' ) |
| // InternalEssentialOCL.g:11752:1: 'extends' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSAccess().getExtendsKeyword_1_0()); |
| } |
| match(input,82,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSAccess().getExtendsKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group_1__1" |
| // InternalEssentialOCL.g:11765:1: rule__TypeParameterCS__Group_1__1 : rule__TypeParameterCS__Group_1__1__Impl rule__TypeParameterCS__Group_1__2 ; |
| public final void rule__TypeParameterCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11769:1: ( rule__TypeParameterCS__Group_1__1__Impl rule__TypeParameterCS__Group_1__2 ) |
| // InternalEssentialOCL.g:11770:2: rule__TypeParameterCS__Group_1__1__Impl rule__TypeParameterCS__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_59); |
| rule__TypeParameterCS__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:11777:1: rule__TypeParameterCS__Group_1__1__Impl : ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) ) ; |
| public final void rule__TypeParameterCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11781:1: ( ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) ) ) |
| // InternalEssentialOCL.g:11782:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:11782:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) ) |
| // InternalEssentialOCL.g:11783:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_1()); |
| } |
| // InternalEssentialOCL.g:11784:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) |
| // InternalEssentialOCL.g:11784:2: rule__TypeParameterCS__OwnedExtendsAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__OwnedExtendsAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group_1__2" |
| // InternalEssentialOCL.g:11794:1: rule__TypeParameterCS__Group_1__2 : rule__TypeParameterCS__Group_1__2__Impl ; |
| public final void rule__TypeParameterCS__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11798:1: ( rule__TypeParameterCS__Group_1__2__Impl ) |
| // InternalEssentialOCL.g:11799:2: rule__TypeParameterCS__Group_1__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__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__TypeParameterCS__Group_1__2" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group_1__2__Impl" |
| // InternalEssentialOCL.g:11805:1: rule__TypeParameterCS__Group_1__2__Impl : ( ( rule__TypeParameterCS__Group_1_2__0 )* ) ; |
| public final void rule__TypeParameterCS__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11809:1: ( ( ( rule__TypeParameterCS__Group_1_2__0 )* ) ) |
| // InternalEssentialOCL.g:11810:1: ( ( rule__TypeParameterCS__Group_1_2__0 )* ) |
| { |
| // InternalEssentialOCL.g:11810:1: ( ( rule__TypeParameterCS__Group_1_2__0 )* ) |
| // InternalEssentialOCL.g:11811:1: ( rule__TypeParameterCS__Group_1_2__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSAccess().getGroup_1_2()); |
| } |
| // InternalEssentialOCL.g:11812:1: ( rule__TypeParameterCS__Group_1_2__0 )* |
| loop96: |
| do { |
| int alt96=2; |
| int LA96_0 = input.LA(1); |
| |
| if ( (LA96_0==83) ) { |
| alt96=1; |
| } |
| |
| |
| switch (alt96) { |
| case 1 : |
| // InternalEssentialOCL.g:11812:2: rule__TypeParameterCS__Group_1_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_60); |
| rule__TypeParameterCS__Group_1_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop96; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSAccess().getGroup_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group_1_2__0" |
| // InternalEssentialOCL.g:11828:1: rule__TypeParameterCS__Group_1_2__0 : rule__TypeParameterCS__Group_1_2__0__Impl rule__TypeParameterCS__Group_1_2__1 ; |
| public final void rule__TypeParameterCS__Group_1_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11832:1: ( rule__TypeParameterCS__Group_1_2__0__Impl rule__TypeParameterCS__Group_1_2__1 ) |
| // InternalEssentialOCL.g:11833:2: rule__TypeParameterCS__Group_1_2__0__Impl rule__TypeParameterCS__Group_1_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__TypeParameterCS__Group_1_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__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__TypeParameterCS__Group_1_2__0" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group_1_2__0__Impl" |
| // InternalEssentialOCL.g:11840:1: rule__TypeParameterCS__Group_1_2__0__Impl : ( '&&' ) ; |
| public final void rule__TypeParameterCS__Group_1_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11844:1: ( ( '&&' ) ) |
| // InternalEssentialOCL.g:11845:1: ( '&&' ) |
| { |
| // InternalEssentialOCL.g:11845:1: ( '&&' ) |
| // InternalEssentialOCL.g:11846:1: '&&' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSAccess().getAmpersandAmpersandKeyword_1_2_0()); |
| } |
| match(input,83,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSAccess().getAmpersandAmpersandKeyword_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group_1_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group_1_2__1" |
| // InternalEssentialOCL.g:11859:1: rule__TypeParameterCS__Group_1_2__1 : rule__TypeParameterCS__Group_1_2__1__Impl ; |
| public final void rule__TypeParameterCS__Group_1_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11863:1: ( rule__TypeParameterCS__Group_1_2__1__Impl ) |
| // InternalEssentialOCL.g:11864:2: rule__TypeParameterCS__Group_1_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__Group_1_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group_1_2__1" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__Group_1_2__1__Impl" |
| // InternalEssentialOCL.g:11870:1: rule__TypeParameterCS__Group_1_2__1__Impl : ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) ) ; |
| public final void rule__TypeParameterCS__Group_1_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11874:1: ( ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) ) ) |
| // InternalEssentialOCL.g:11875:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:11875:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) ) |
| // InternalEssentialOCL.g:11876:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_2_1()); |
| } |
| // InternalEssentialOCL.g:11877:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) |
| // InternalEssentialOCL.g:11877:2: rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__Group_1_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__Group__0" |
| // InternalEssentialOCL.g:11891:1: rule__TypedTypeRefCS__Group__0 : rule__TypedTypeRefCS__Group__0__Impl rule__TypedTypeRefCS__Group__1 ; |
| public final void rule__TypedTypeRefCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11895:1: ( rule__TypedTypeRefCS__Group__0__Impl rule__TypedTypeRefCS__Group__1 ) |
| // InternalEssentialOCL.g:11896:2: rule__TypedTypeRefCS__Group__0__Impl rule__TypedTypeRefCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_5); |
| rule__TypedTypeRefCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypedTypeRefCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypedTypeRefCS__Group__0" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__Group__0__Impl" |
| // InternalEssentialOCL.g:11903:1: rule__TypedTypeRefCS__Group__0__Impl : ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) ) ; |
| public final void rule__TypedTypeRefCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11907:1: ( ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) ) ) |
| // InternalEssentialOCL.g:11908:1: ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) ) |
| { |
| // InternalEssentialOCL.g:11908:1: ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) ) |
| // InternalEssentialOCL.g:11909:1: ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNameAssignment_0()); |
| } |
| // InternalEssentialOCL.g:11910:1: ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) |
| // InternalEssentialOCL.g:11910:2: rule__TypedTypeRefCS__OwnedPathNameAssignment_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypedTypeRefCS__OwnedPathNameAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNameAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypedTypeRefCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__Group__1" |
| // InternalEssentialOCL.g:11920:1: rule__TypedTypeRefCS__Group__1 : rule__TypedTypeRefCS__Group__1__Impl ; |
| public final void rule__TypedTypeRefCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11924:1: ( rule__TypedTypeRefCS__Group__1__Impl ) |
| // InternalEssentialOCL.g:11925:2: rule__TypedTypeRefCS__Group__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypedTypeRefCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypedTypeRefCS__Group__1" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__Group__1__Impl" |
| // InternalEssentialOCL.g:11931:1: rule__TypedTypeRefCS__Group__1__Impl : ( ( rule__TypedTypeRefCS__Group_1__0 )? ) ; |
| public final void rule__TypedTypeRefCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11935:1: ( ( ( rule__TypedTypeRefCS__Group_1__0 )? ) ) |
| // InternalEssentialOCL.g:11936:1: ( ( rule__TypedTypeRefCS__Group_1__0 )? ) |
| { |
| // InternalEssentialOCL.g:11936:1: ( ( rule__TypedTypeRefCS__Group_1__0 )? ) |
| // InternalEssentialOCL.g:11937:1: ( rule__TypedTypeRefCS__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypedTypeRefCSAccess().getGroup_1()); |
| } |
| // InternalEssentialOCL.g:11938:1: ( rule__TypedTypeRefCS__Group_1__0 )? |
| int alt97=2; |
| int LA97_0 = input.LA(1); |
| |
| if ( (LA97_0==59) ) { |
| alt97=1; |
| } |
| switch (alt97) { |
| case 1 : |
| // InternalEssentialOCL.g:11938:2: rule__TypedTypeRefCS__Group_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypedTypeRefCS__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypedTypeRefCSAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypedTypeRefCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__Group_1__0" |
| // InternalEssentialOCL.g:11952:1: rule__TypedTypeRefCS__Group_1__0 : rule__TypedTypeRefCS__Group_1__0__Impl rule__TypedTypeRefCS__Group_1__1 ; |
| public final void rule__TypedTypeRefCS__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11956:1: ( rule__TypedTypeRefCS__Group_1__0__Impl rule__TypedTypeRefCS__Group_1__1 ) |
| // InternalEssentialOCL.g:11957:2: rule__TypedTypeRefCS__Group_1__0__Impl rule__TypedTypeRefCS__Group_1__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_57); |
| rule__TypedTypeRefCS__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypedTypeRefCS__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypedTypeRefCS__Group_1__0" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__Group_1__0__Impl" |
| // InternalEssentialOCL.g:11964:1: rule__TypedTypeRefCS__Group_1__0__Impl : ( '(' ) ; |
| public final void rule__TypedTypeRefCS__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11968:1: ( ( '(' ) ) |
| // InternalEssentialOCL.g:11969:1: ( '(' ) |
| { |
| // InternalEssentialOCL.g:11969:1: ( '(' ) |
| // InternalEssentialOCL.g:11970:1: '(' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypedTypeRefCSAccess().getLeftParenthesisKeyword_1_0()); |
| } |
| match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypedTypeRefCSAccess().getLeftParenthesisKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypedTypeRefCS__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__Group_1__1" |
| // InternalEssentialOCL.g:11983:1: rule__TypedTypeRefCS__Group_1__1 : rule__TypedTypeRefCS__Group_1__1__Impl rule__TypedTypeRefCS__Group_1__2 ; |
| public final void rule__TypedTypeRefCS__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11987:1: ( rule__TypedTypeRefCS__Group_1__1__Impl rule__TypedTypeRefCS__Group_1__2 ) |
| // InternalEssentialOCL.g:11988:2: rule__TypedTypeRefCS__Group_1__1__Impl rule__TypedTypeRefCS__Group_1__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_9); |
| rule__TypedTypeRefCS__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypedTypeRefCS__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypedTypeRefCS__Group_1__1" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__Group_1__1__Impl" |
| // InternalEssentialOCL.g:11995:1: rule__TypedTypeRefCS__Group_1__1__Impl : ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) ) ; |
| public final void rule__TypedTypeRefCS__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:11999:1: ( ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) ) ) |
| // InternalEssentialOCL.g:12000:1: ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) ) |
| { |
| // InternalEssentialOCL.g:12000:1: ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) ) |
| // InternalEssentialOCL.g:12001:1: ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingAssignment_1_1()); |
| } |
| // InternalEssentialOCL.g:12002:1: ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) |
| // InternalEssentialOCL.g:12002:2: rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypedTypeRefCS__OwnedBindingAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypedTypeRefCS__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__Group_1__2" |
| // InternalEssentialOCL.g:12012:1: rule__TypedTypeRefCS__Group_1__2 : rule__TypedTypeRefCS__Group_1__2__Impl ; |
| public final void rule__TypedTypeRefCS__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12016:1: ( rule__TypedTypeRefCS__Group_1__2__Impl ) |
| // InternalEssentialOCL.g:12017:2: rule__TypedTypeRefCS__Group_1__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__TypedTypeRefCS__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__TypedTypeRefCS__Group_1__2" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__Group_1__2__Impl" |
| // InternalEssentialOCL.g:12023:1: rule__TypedTypeRefCS__Group_1__2__Impl : ( ')' ) ; |
| public final void rule__TypedTypeRefCS__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12027:1: ( ( ')' ) ) |
| // InternalEssentialOCL.g:12028:1: ( ')' ) |
| { |
| // InternalEssentialOCL.g:12028:1: ( ')' ) |
| // InternalEssentialOCL.g:12029:1: ')' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypedTypeRefCSAccess().getRightParenthesisKeyword_1_2()); |
| } |
| match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypedTypeRefCSAccess().getRightParenthesisKeyword_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypedTypeRefCS__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__WildcardTypeRefCS__Group__0" |
| // InternalEssentialOCL.g:12048:1: rule__WildcardTypeRefCS__Group__0 : rule__WildcardTypeRefCS__Group__0__Impl rule__WildcardTypeRefCS__Group__1 ; |
| public final void rule__WildcardTypeRefCS__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12052:1: ( rule__WildcardTypeRefCS__Group__0__Impl rule__WildcardTypeRefCS__Group__1 ) |
| // InternalEssentialOCL.g:12053:2: rule__WildcardTypeRefCS__Group__0__Impl rule__WildcardTypeRefCS__Group__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_57); |
| rule__WildcardTypeRefCS__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__WildcardTypeRefCS__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__WildcardTypeRefCS__Group__0" |
| |
| |
| // $ANTLR start "rule__WildcardTypeRefCS__Group__0__Impl" |
| // InternalEssentialOCL.g:12060:1: rule__WildcardTypeRefCS__Group__0__Impl : ( () ) ; |
| public final void rule__WildcardTypeRefCS__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12064:1: ( ( () ) ) |
| // InternalEssentialOCL.g:12065:1: ( () ) |
| { |
| // InternalEssentialOCL.g:12065:1: ( () ) |
| // InternalEssentialOCL.g:12066:1: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWildcardTypeRefCSAccess().getWildcardTypeRefCSAction_0()); |
| } |
| // InternalEssentialOCL.g:12067:1: () |
| // InternalEssentialOCL.g:12069:1: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWildcardTypeRefCSAccess().getWildcardTypeRefCSAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__WildcardTypeRefCS__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__WildcardTypeRefCS__Group__1" |
| // InternalEssentialOCL.g:12079:1: rule__WildcardTypeRefCS__Group__1 : rule__WildcardTypeRefCS__Group__1__Impl rule__WildcardTypeRefCS__Group__2 ; |
| public final void rule__WildcardTypeRefCS__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12083:1: ( rule__WildcardTypeRefCS__Group__1__Impl rule__WildcardTypeRefCS__Group__2 ) |
| // InternalEssentialOCL.g:12084:2: rule__WildcardTypeRefCS__Group__1__Impl rule__WildcardTypeRefCS__Group__2 |
| { |
| pushFollow(FollowSets000.FOLLOW_58); |
| rule__WildcardTypeRefCS__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__WildcardTypeRefCS__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__WildcardTypeRefCS__Group__1" |
| |
| |
| // $ANTLR start "rule__WildcardTypeRefCS__Group__1__Impl" |
| // InternalEssentialOCL.g:12091:1: rule__WildcardTypeRefCS__Group__1__Impl : ( '?' ) ; |
| public final void rule__WildcardTypeRefCS__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12095:1: ( ( '?' ) ) |
| // InternalEssentialOCL.g:12096:1: ( '?' ) |
| { |
| // InternalEssentialOCL.g:12096:1: ( '?' ) |
| // InternalEssentialOCL.g:12097:1: '?' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWildcardTypeRefCSAccess().getQuestionMarkKeyword_1()); |
| } |
| match(input,58,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWildcardTypeRefCSAccess().getQuestionMarkKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__WildcardTypeRefCS__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__WildcardTypeRefCS__Group__2" |
| // InternalEssentialOCL.g:12110:1: rule__WildcardTypeRefCS__Group__2 : rule__WildcardTypeRefCS__Group__2__Impl ; |
| public final void rule__WildcardTypeRefCS__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12114:1: ( rule__WildcardTypeRefCS__Group__2__Impl ) |
| // InternalEssentialOCL.g:12115:2: rule__WildcardTypeRefCS__Group__2__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__WildcardTypeRefCS__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__WildcardTypeRefCS__Group__2" |
| |
| |
| // $ANTLR start "rule__WildcardTypeRefCS__Group__2__Impl" |
| // InternalEssentialOCL.g:12121:1: rule__WildcardTypeRefCS__Group__2__Impl : ( ( rule__WildcardTypeRefCS__Group_2__0 )? ) ; |
| public final void rule__WildcardTypeRefCS__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12125:1: ( ( ( rule__WildcardTypeRefCS__Group_2__0 )? ) ) |
| // InternalEssentialOCL.g:12126:1: ( ( rule__WildcardTypeRefCS__Group_2__0 )? ) |
| { |
| // InternalEssentialOCL.g:12126:1: ( ( rule__WildcardTypeRefCS__Group_2__0 )? ) |
| // InternalEssentialOCL.g:12127:1: ( rule__WildcardTypeRefCS__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWildcardTypeRefCSAccess().getGroup_2()); |
| } |
| // InternalEssentialOCL.g:12128:1: ( rule__WildcardTypeRefCS__Group_2__0 )? |
| int alt98=2; |
| int LA98_0 = input.LA(1); |
| |
| if ( (LA98_0==82) ) { |
| alt98=1; |
| } |
| switch (alt98) { |
| case 1 : |
| // InternalEssentialOCL.g:12128:2: rule__WildcardTypeRefCS__Group_2__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__WildcardTypeRefCS__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWildcardTypeRefCSAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__WildcardTypeRefCS__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__WildcardTypeRefCS__Group_2__0" |
| // InternalEssentialOCL.g:12144:1: rule__WildcardTypeRefCS__Group_2__0 : rule__WildcardTypeRefCS__Group_2__0__Impl rule__WildcardTypeRefCS__Group_2__1 ; |
| public final void rule__WildcardTypeRefCS__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12148:1: ( rule__WildcardTypeRefCS__Group_2__0__Impl rule__WildcardTypeRefCS__Group_2__1 ) |
| // InternalEssentialOCL.g:12149:2: rule__WildcardTypeRefCS__Group_2__0__Impl rule__WildcardTypeRefCS__Group_2__1 |
| { |
| pushFollow(FollowSets000.FOLLOW_12); |
| rule__WildcardTypeRefCS__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__WildcardTypeRefCS__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__WildcardTypeRefCS__Group_2__0" |
| |
| |
| // $ANTLR start "rule__WildcardTypeRefCS__Group_2__0__Impl" |
| // InternalEssentialOCL.g:12156:1: rule__WildcardTypeRefCS__Group_2__0__Impl : ( 'extends' ) ; |
| public final void rule__WildcardTypeRefCS__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12160:1: ( ( 'extends' ) ) |
| // InternalEssentialOCL.g:12161:1: ( 'extends' ) |
| { |
| // InternalEssentialOCL.g:12161:1: ( 'extends' ) |
| // InternalEssentialOCL.g:12162:1: 'extends' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWildcardTypeRefCSAccess().getExtendsKeyword_2_0()); |
| } |
| match(input,82,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWildcardTypeRefCSAccess().getExtendsKeyword_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__WildcardTypeRefCS__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__WildcardTypeRefCS__Group_2__1" |
| // InternalEssentialOCL.g:12175:1: rule__WildcardTypeRefCS__Group_2__1 : rule__WildcardTypeRefCS__Group_2__1__Impl ; |
| public final void rule__WildcardTypeRefCS__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12179:1: ( rule__WildcardTypeRefCS__Group_2__1__Impl ) |
| // InternalEssentialOCL.g:12180:2: rule__WildcardTypeRefCS__Group_2__1__Impl |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__WildcardTypeRefCS__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__WildcardTypeRefCS__Group_2__1" |
| |
| |
| // $ANTLR start "rule__WildcardTypeRefCS__Group_2__1__Impl" |
| // InternalEssentialOCL.g:12186:1: rule__WildcardTypeRefCS__Group_2__1__Impl : ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) ) ; |
| public final void rule__WildcardTypeRefCS__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12190:1: ( ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) ) ) |
| // InternalEssentialOCL.g:12191:1: ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) ) |
| { |
| // InternalEssentialOCL.g:12191:1: ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) ) |
| // InternalEssentialOCL.g:12192:1: ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsAssignment_2_1()); |
| } |
| // InternalEssentialOCL.g:12193:1: ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) |
| // InternalEssentialOCL.g:12193:2: rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsAssignment_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__WildcardTypeRefCS__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__Model__OwnedExpressionAssignment" |
| // InternalEssentialOCL.g:12208:1: rule__Model__OwnedExpressionAssignment : ( ruleExpCS ) ; |
| public final void rule__Model__OwnedExpressionAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12212:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:12213:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:12213:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:12214:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getModelAccess().getOwnedExpressionExpCSParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getModelAccess().getOwnedExpressionExpCSParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Model__OwnedExpressionAssignment" |
| |
| |
| // $ANTLR start "rule__URIFirstPathElementCS__ReferredElementAssignment_0" |
| // InternalEssentialOCL.g:12225:1: rule__URIFirstPathElementCS__ReferredElementAssignment_0 : ( ( ruleUnrestrictedName ) ) ; |
| public final void rule__URIFirstPathElementCS__ReferredElementAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12229:1: ( ( ( ruleUnrestrictedName ) ) ) |
| // InternalEssentialOCL.g:12230:1: ( ( ruleUnrestrictedName ) ) |
| { |
| // InternalEssentialOCL.g:12230:1: ( ( ruleUnrestrictedName ) ) |
| // InternalEssentialOCL.g:12231:1: ( ruleUnrestrictedName ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0_0()); |
| } |
| // InternalEssentialOCL.g:12232:1: ( ruleUnrestrictedName ) |
| // InternalEssentialOCL.g:12233:1: ruleUnrestrictedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__URIFirstPathElementCS__ReferredElementAssignment_0" |
| |
| |
| // $ANTLR start "rule__URIFirstPathElementCS__ReferredElementAssignment_1_1" |
| // InternalEssentialOCL.g:12244:1: rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 : ( ( ruleURI ) ) ; |
| public final void rule__URIFirstPathElementCS__ReferredElementAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12248:1: ( ( ( ruleURI ) ) ) |
| // InternalEssentialOCL.g:12249:1: ( ( ruleURI ) ) |
| { |
| // InternalEssentialOCL.g:12249:1: ( ( ruleURI ) ) |
| // InternalEssentialOCL.g:12250:1: ( ruleURI ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceCrossReference_1_1_0()); |
| } |
| // InternalEssentialOCL.g:12251:1: ( ruleURI ) |
| // InternalEssentialOCL.g:12252:1: ruleURI |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceURIParserRuleCall_1_1_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleURI(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceURIParserRuleCall_1_1_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceCrossReference_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__URIFirstPathElementCS__ReferredElementAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__PrimitiveTypeCS__NameAssignment" |
| // InternalEssentialOCL.g:12264:1: rule__PrimitiveTypeCS__NameAssignment : ( rulePrimitiveTypeIdentifier ) ; |
| public final void rule__PrimitiveTypeCS__NameAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12268:1: ( ( rulePrimitiveTypeIdentifier ) ) |
| // InternalEssentialOCL.g:12269:1: ( rulePrimitiveTypeIdentifier ) |
| { |
| // InternalEssentialOCL.g:12269:1: ( rulePrimitiveTypeIdentifier ) |
| // InternalEssentialOCL.g:12270:1: rulePrimitiveTypeIdentifier |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimitiveTypeCSAccess().getNamePrimitiveTypeIdentifierParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePrimitiveTypeIdentifier(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrimitiveTypeCSAccess().getNamePrimitiveTypeIdentifierParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrimitiveTypeCS__NameAssignment" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__NameAssignment_0" |
| // InternalEssentialOCL.g:12279:1: rule__CollectionTypeCS__NameAssignment_0 : ( ruleCollectionTypeIdentifier ) ; |
| public final void rule__CollectionTypeCS__NameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12283:1: ( ( ruleCollectionTypeIdentifier ) ) |
| // InternalEssentialOCL.g:12284:1: ( ruleCollectionTypeIdentifier ) |
| { |
| // InternalEssentialOCL.g:12284:1: ( ruleCollectionTypeIdentifier ) |
| // InternalEssentialOCL.g:12285:1: ruleCollectionTypeIdentifier |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeCSAccess().getNameCollectionTypeIdentifierParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCollectionTypeIdentifier(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeCSAccess().getNameCollectionTypeIdentifierParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__NameAssignment_0" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__OwnedTypeAssignment_1_1" |
| // InternalEssentialOCL.g:12294:1: rule__CollectionTypeCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpWithoutMultiplicityCS ) ; |
| public final void rule__CollectionTypeCS__OwnedTypeAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12298:1: ( ( ruleTypeExpWithoutMultiplicityCS ) ) |
| // InternalEssentialOCL.g:12299:1: ( ruleTypeExpWithoutMultiplicityCS ) |
| { |
| // InternalEssentialOCL.g:12299:1: ( ruleTypeExpWithoutMultiplicityCS ) |
| // InternalEssentialOCL.g:12300:1: ruleTypeExpWithoutMultiplicityCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeTypeExpWithoutMultiplicityCSParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpWithoutMultiplicityCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeTypeExpWithoutMultiplicityCSParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__OwnedTypeAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2" |
| // InternalEssentialOCL.g:12309:1: rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 : ( ruleMultiplicityCS ) ; |
| public final void rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12313:1: ( ( ruleMultiplicityCS ) ) |
| // InternalEssentialOCL.g:12314:1: ( ruleMultiplicityCS ) |
| { |
| // InternalEssentialOCL.g:12314:1: ( ruleMultiplicityCS ) |
| // InternalEssentialOCL.g:12315:1: ruleMultiplicityCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityMultiplicityCSParserRuleCall_1_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMultiplicityCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityMultiplicityCSParserRuleCall_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__NameAssignment_0" |
| // InternalEssentialOCL.g:12324:1: rule__MapTypeCS__NameAssignment_0 : ( ( 'Map' ) ) ; |
| public final void rule__MapTypeCS__NameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12328:1: ( ( ( 'Map' ) ) ) |
| // InternalEssentialOCL.g:12329:1: ( ( 'Map' ) ) |
| { |
| // InternalEssentialOCL.g:12329:1: ( ( 'Map' ) ) |
| // InternalEssentialOCL.g:12330:1: ( 'Map' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0()); |
| } |
| // InternalEssentialOCL.g:12331:1: ( 'Map' ) |
| // InternalEssentialOCL.g:12332:1: 'Map' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0()); |
| } |
| match(input,40,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__NameAssignment_0" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__OwnedKeyTypeAssignment_1_1" |
| // InternalEssentialOCL.g:12347:1: rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 : ( ruleTypeExpCS ) ; |
| public final void rule__MapTypeCS__OwnedKeyTypeAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12351:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:12352:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:12352:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:12353:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeTypeExpCSParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeTypeExpCSParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__OwnedKeyTypeAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__MapTypeCS__OwnedValueTypeAssignment_1_3" |
| // InternalEssentialOCL.g:12362:1: rule__MapTypeCS__OwnedValueTypeAssignment_1_3 : ( ruleTypeExpCS ) ; |
| public final void rule__MapTypeCS__OwnedValueTypeAssignment_1_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12366:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:12367:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:12367:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:12368:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeTypeExpCSParserRuleCall_1_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeTypeExpCSParserRuleCall_1_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapTypeCS__OwnedValueTypeAssignment_1_3" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__NameAssignment_0" |
| // InternalEssentialOCL.g:12377:1: rule__TupleTypeCS__NameAssignment_0 : ( ( 'Tuple' ) ) ; |
| public final void rule__TupleTypeCS__NameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12381:1: ( ( ( 'Tuple' ) ) ) |
| // InternalEssentialOCL.g:12382:1: ( ( 'Tuple' ) ) |
| { |
| // InternalEssentialOCL.g:12382:1: ( ( 'Tuple' ) ) |
| // InternalEssentialOCL.g:12383:1: ( 'Tuple' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0()); |
| } |
| // InternalEssentialOCL.g:12384:1: ( 'Tuple' ) |
| // InternalEssentialOCL.g:12385:1: 'Tuple' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0()); |
| } |
| match(input,41,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__NameAssignment_0" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__OwnedPartsAssignment_1_1_0" |
| // InternalEssentialOCL.g:12400:1: rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 : ( ruleTuplePartCS ) ; |
| public final void rule__TupleTypeCS__OwnedPartsAssignment_1_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12404:1: ( ( ruleTuplePartCS ) ) |
| // InternalEssentialOCL.g:12405:1: ( ruleTuplePartCS ) |
| { |
| // InternalEssentialOCL.g:12405:1: ( ruleTuplePartCS ) |
| // InternalEssentialOCL.g:12406:1: ruleTuplePartCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTuplePartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__OwnedPartsAssignment_1_1_0" |
| |
| |
| // $ANTLR start "rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1" |
| // InternalEssentialOCL.g:12415:1: rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 : ( ruleTuplePartCS ) ; |
| public final void rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12419:1: ( ( ruleTuplePartCS ) ) |
| // InternalEssentialOCL.g:12420:1: ( ruleTuplePartCS ) |
| { |
| // InternalEssentialOCL.g:12420:1: ( ruleTuplePartCS ) |
| // InternalEssentialOCL.g:12421:1: ruleTuplePartCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTuplePartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1" |
| |
| |
| // $ANTLR start "rule__TuplePartCS__NameAssignment_0" |
| // InternalEssentialOCL.g:12430:1: rule__TuplePartCS__NameAssignment_0 : ( ruleUnrestrictedName ) ; |
| public final void rule__TuplePartCS__NameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12434:1: ( ( ruleUnrestrictedName ) ) |
| // InternalEssentialOCL.g:12435:1: ( ruleUnrestrictedName ) |
| { |
| // InternalEssentialOCL.g:12435:1: ( ruleUnrestrictedName ) |
| // InternalEssentialOCL.g:12436:1: ruleUnrestrictedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTuplePartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTuplePartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TuplePartCS__NameAssignment_0" |
| |
| |
| // $ANTLR start "rule__TuplePartCS__OwnedTypeAssignment_2" |
| // InternalEssentialOCL.g:12445:1: rule__TuplePartCS__OwnedTypeAssignment_2 : ( ruleTypeExpCS ) ; |
| public final void rule__TuplePartCS__OwnedTypeAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12449:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:12450:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:12450:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:12451:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTuplePartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTuplePartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TuplePartCS__OwnedTypeAssignment_2" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__OwnedTypeAssignment_0" |
| // InternalEssentialOCL.g:12460:1: rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 : ( ruleCollectionTypeCS ) ; |
| public final void rule__CollectionLiteralExpCS__OwnedTypeAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12464:1: ( ( ruleCollectionTypeCS ) ) |
| // InternalEssentialOCL.g:12465:1: ( ruleCollectionTypeCS ) |
| { |
| // InternalEssentialOCL.g:12465:1: ( ruleCollectionTypeCS ) |
| // InternalEssentialOCL.g:12466:1: ruleCollectionTypeCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCollectionTypeCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__OwnedTypeAssignment_0" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0" |
| // InternalEssentialOCL.g:12475:1: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 : ( ruleCollectionLiteralPartCS ) ; |
| public final void rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12479:1: ( ( ruleCollectionLiteralPartCS ) ) |
| // InternalEssentialOCL.g:12480:1: ( ruleCollectionLiteralPartCS ) |
| { |
| // InternalEssentialOCL.g:12480:1: ( ruleCollectionLiteralPartCS ) |
| // InternalEssentialOCL.g:12481:1: ruleCollectionLiteralPartCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCollectionLiteralPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1" |
| // InternalEssentialOCL.g:12490:1: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 : ( ruleCollectionLiteralPartCS ) ; |
| public final void rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12494:1: ( ( ruleCollectionLiteralPartCS ) ) |
| // InternalEssentialOCL.g:12495:1: ( ruleCollectionLiteralPartCS ) |
| { |
| // InternalEssentialOCL.g:12495:1: ( ruleCollectionLiteralPartCS ) |
| // InternalEssentialOCL.g:12496:1: ruleCollectionLiteralPartCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCollectionLiteralPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0" |
| // InternalEssentialOCL.g:12505:1: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 : ( ruleExpCS ) ; |
| public final void rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12509:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:12510:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:12510:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:12511:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionExpCSParserRuleCall_0_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionExpCSParserRuleCall_0_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1" |
| // InternalEssentialOCL.g:12520:1: rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 : ( ruleExpCS ) ; |
| public final void rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12524:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:12525:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:12525:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:12526:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionExpCSParserRuleCall_0_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionExpCSParserRuleCall_0_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1" |
| |
| |
| // $ANTLR start "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1" |
| // InternalEssentialOCL.g:12535:1: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 : ( rulePatternExpCS ) ; |
| public final void rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12539:1: ( ( rulePatternExpCS ) ) |
| // InternalEssentialOCL.g:12540:1: ( rulePatternExpCS ) |
| { |
| // InternalEssentialOCL.g:12540:1: ( rulePatternExpCS ) |
| // InternalEssentialOCL.g:12541:1: rulePatternExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionPatternExpCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePatternExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionPatternExpCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__OwnedTypeAssignment_0" |
| // InternalEssentialOCL.g:12550:1: rule__CollectionPatternCS__OwnedTypeAssignment_0 : ( ruleCollectionTypeCS ) ; |
| public final void rule__CollectionPatternCS__OwnedTypeAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12554:1: ( ( ruleCollectionTypeCS ) ) |
| // InternalEssentialOCL.g:12555:1: ( ruleCollectionTypeCS ) |
| { |
| // InternalEssentialOCL.g:12555:1: ( ruleCollectionTypeCS ) |
| // InternalEssentialOCL.g:12556:1: ruleCollectionTypeCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCollectionTypeCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__OwnedTypeAssignment_0" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__OwnedPartsAssignment_2_0" |
| // InternalEssentialOCL.g:12565:1: rule__CollectionPatternCS__OwnedPartsAssignment_2_0 : ( rulePatternExpCS ) ; |
| public final void rule__CollectionPatternCS__OwnedPartsAssignment_2_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12569:1: ( ( rulePatternExpCS ) ) |
| // InternalEssentialOCL.g:12570:1: ( rulePatternExpCS ) |
| { |
| // InternalEssentialOCL.g:12570:1: ( rulePatternExpCS ) |
| // InternalEssentialOCL.g:12571:1: rulePatternExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePatternExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__OwnedPartsAssignment_2_0" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1" |
| // InternalEssentialOCL.g:12580:1: rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 : ( rulePatternExpCS ) ; |
| public final void rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12584:1: ( ( rulePatternExpCS ) ) |
| // InternalEssentialOCL.g:12585:1: ( rulePatternExpCS ) |
| { |
| // InternalEssentialOCL.g:12585:1: ( rulePatternExpCS ) |
| // InternalEssentialOCL.g:12586:1: rulePatternExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePatternExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1" |
| |
| |
| // $ANTLR start "rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1" |
| // InternalEssentialOCL.g:12595:1: rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 : ( ruleIdentifier ) ; |
| public final void rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12599:1: ( ( ruleIdentifier ) ) |
| // InternalEssentialOCL.g:12600:1: ( ruleIdentifier ) |
| { |
| // InternalEssentialOCL.g:12600:1: ( ruleIdentifier ) |
| // InternalEssentialOCL.g:12601:1: ruleIdentifier |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameIdentifierParserRuleCall_2_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleIdentifier(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameIdentifierParserRuleCall_2_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1" |
| |
| |
| // $ANTLR start "rule__ShadowPartCS__ReferredPropertyAssignment_0_0" |
| // InternalEssentialOCL.g:12610:1: rule__ShadowPartCS__ReferredPropertyAssignment_0_0 : ( ( ruleUnrestrictedName ) ) ; |
| public final void rule__ShadowPartCS__ReferredPropertyAssignment_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12614:1: ( ( ( ruleUnrestrictedName ) ) ) |
| // InternalEssentialOCL.g:12615:1: ( ( ruleUnrestrictedName ) ) |
| { |
| // InternalEssentialOCL.g:12615:1: ( ( ruleUnrestrictedName ) ) |
| // InternalEssentialOCL.g:12616:1: ( ruleUnrestrictedName ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyCrossReference_0_0_0()); |
| } |
| // InternalEssentialOCL.g:12617:1: ( ruleUnrestrictedName ) |
| // InternalEssentialOCL.g:12618:1: ruleUnrestrictedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyUnrestrictedNameParserRuleCall_0_0_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyUnrestrictedNameParserRuleCall_0_0_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyCrossReference_0_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ShadowPartCS__ReferredPropertyAssignment_0_0" |
| |
| |
| // $ANTLR start "rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2" |
| // InternalEssentialOCL.g:12629:1: rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 : ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) ) ; |
| public final void rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12633:1: ( ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) ) ) |
| // InternalEssentialOCL.g:12634:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) ) |
| { |
| // InternalEssentialOCL.g:12634:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) ) |
| // InternalEssentialOCL.g:12635:1: ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAlternatives_0_2_0()); |
| } |
| // InternalEssentialOCL.g:12636:1: ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) |
| // InternalEssentialOCL.g:12636:2: rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAlternatives_0_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2" |
| |
| |
| // $ANTLR start "rule__ShadowPartCS__OwnedInitExpressionAssignment_1" |
| // InternalEssentialOCL.g:12645:1: rule__ShadowPartCS__OwnedInitExpressionAssignment_1 : ( ruleStringLiteralExpCS ) ; |
| public final void rule__ShadowPartCS__OwnedInitExpressionAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12649:1: ( ( ruleStringLiteralExpCS ) ) |
| // InternalEssentialOCL.g:12650:1: ( ruleStringLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:12650:1: ( ruleStringLiteralExpCS ) |
| // InternalEssentialOCL.g:12651:1: ruleStringLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionStringLiteralExpCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleStringLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionStringLiteralExpCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ShadowPartCS__OwnedInitExpressionAssignment_1" |
| |
| |
| // $ANTLR start "rule__PatternExpCS__PatternVariableNameAssignment_0" |
| // InternalEssentialOCL.g:12660:1: rule__PatternExpCS__PatternVariableNameAssignment_0 : ( ruleUnrestrictedName ) ; |
| public final void rule__PatternExpCS__PatternVariableNameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12664:1: ( ( ruleUnrestrictedName ) ) |
| // InternalEssentialOCL.g:12665:1: ( ruleUnrestrictedName ) |
| { |
| // InternalEssentialOCL.g:12665:1: ( ruleUnrestrictedName ) |
| // InternalEssentialOCL.g:12666:1: ruleUnrestrictedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPatternExpCSAccess().getPatternVariableNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPatternExpCSAccess().getPatternVariableNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PatternExpCS__PatternVariableNameAssignment_0" |
| |
| |
| // $ANTLR start "rule__PatternExpCS__OwnedPatternTypeAssignment_2" |
| // InternalEssentialOCL.g:12675:1: rule__PatternExpCS__OwnedPatternTypeAssignment_2 : ( ruleTypeExpCS ) ; |
| public final void rule__PatternExpCS__OwnedPatternTypeAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12679:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:12680:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:12680:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:12681:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeTypeExpCSParserRuleCall_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeTypeExpCSParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PatternExpCS__OwnedPatternTypeAssignment_2" |
| |
| |
| // $ANTLR start "rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2" |
| // InternalEssentialOCL.g:12690:1: rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 : ( ruleExpCS ) ; |
| public final void rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12694:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:12695:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:12695:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:12696:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSExpCSParserRuleCall_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSExpCSParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__OwnedTypeAssignment_0" |
| // InternalEssentialOCL.g:12705:1: rule__MapLiteralExpCS__OwnedTypeAssignment_0 : ( ruleMapTypeCS ) ; |
| public final void rule__MapLiteralExpCS__OwnedTypeAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12709:1: ( ( ruleMapTypeCS ) ) |
| // InternalEssentialOCL.g:12710:1: ( ruleMapTypeCS ) |
| { |
| // InternalEssentialOCL.g:12710:1: ( ruleMapTypeCS ) |
| // InternalEssentialOCL.g:12711:1: ruleMapTypeCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeMapTypeCSParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMapTypeCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeMapTypeCSParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__OwnedTypeAssignment_0" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__OwnedPartsAssignment_2_0" |
| // InternalEssentialOCL.g:12720:1: rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 : ( ruleMapLiteralPartCS ) ; |
| public final void rule__MapLiteralExpCS__OwnedPartsAssignment_2_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12724:1: ( ( ruleMapLiteralPartCS ) ) |
| // InternalEssentialOCL.g:12725:1: ( ruleMapLiteralPartCS ) |
| { |
| // InternalEssentialOCL.g:12725:1: ( ruleMapLiteralPartCS ) |
| // InternalEssentialOCL.g:12726:1: ruleMapLiteralPartCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMapLiteralPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__OwnedPartsAssignment_2_0" |
| |
| |
| // $ANTLR start "rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1" |
| // InternalEssentialOCL.g:12735:1: rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 : ( ruleMapLiteralPartCS ) ; |
| public final void rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12739:1: ( ( ruleMapLiteralPartCS ) ) |
| // InternalEssentialOCL.g:12740:1: ( ruleMapLiteralPartCS ) |
| { |
| // InternalEssentialOCL.g:12740:1: ( ruleMapLiteralPartCS ) |
| // InternalEssentialOCL.g:12741:1: ruleMapLiteralPartCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMapLiteralPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1" |
| |
| |
| // $ANTLR start "rule__MapLiteralPartCS__OwnedKeyAssignment_0" |
| // InternalEssentialOCL.g:12750:1: rule__MapLiteralPartCS__OwnedKeyAssignment_0 : ( ruleExpCS ) ; |
| public final void rule__MapLiteralPartCS__OwnedKeyAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12754:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:12755:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:12755:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:12756:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyExpCSParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyExpCSParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralPartCS__OwnedKeyAssignment_0" |
| |
| |
| // $ANTLR start "rule__MapLiteralPartCS__OwnedValueAssignment_2" |
| // InternalEssentialOCL.g:12765:1: rule__MapLiteralPartCS__OwnedValueAssignment_2 : ( ruleExpCS ) ; |
| public final void rule__MapLiteralPartCS__OwnedValueAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12769:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:12770:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:12770:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:12771:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueExpCSParserRuleCall_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueExpCSParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MapLiteralPartCS__OwnedValueAssignment_2" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__OwnedPartsAssignment_2" |
| // InternalEssentialOCL.g:12780:1: rule__TupleLiteralExpCS__OwnedPartsAssignment_2 : ( ruleTupleLiteralPartCS ) ; |
| public final void rule__TupleLiteralExpCS__OwnedPartsAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12784:1: ( ( ruleTupleLiteralPartCS ) ) |
| // InternalEssentialOCL.g:12785:1: ( ruleTupleLiteralPartCS ) |
| { |
| // InternalEssentialOCL.g:12785:1: ( ruleTupleLiteralPartCS ) |
| // InternalEssentialOCL.g:12786:1: ruleTupleLiteralPartCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTupleLiteralPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__OwnedPartsAssignment_2" |
| |
| |
| // $ANTLR start "rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1" |
| // InternalEssentialOCL.g:12795:1: rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 : ( ruleTupleLiteralPartCS ) ; |
| public final void rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12799:1: ( ( ruleTupleLiteralPartCS ) ) |
| // InternalEssentialOCL.g:12800:1: ( ruleTupleLiteralPartCS ) |
| { |
| // InternalEssentialOCL.g:12800:1: ( ruleTupleLiteralPartCS ) |
| // InternalEssentialOCL.g:12801:1: ruleTupleLiteralPartCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_3_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTupleLiteralPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__NameAssignment_0" |
| // InternalEssentialOCL.g:12810:1: rule__TupleLiteralPartCS__NameAssignment_0 : ( ruleUnrestrictedName ) ; |
| public final void rule__TupleLiteralPartCS__NameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12814:1: ( ( ruleUnrestrictedName ) ) |
| // InternalEssentialOCL.g:12815:1: ( ruleUnrestrictedName ) |
| { |
| // InternalEssentialOCL.g:12815:1: ( ruleUnrestrictedName ) |
| // InternalEssentialOCL.g:12816:1: ruleUnrestrictedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralPartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralPartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__NameAssignment_0" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1" |
| // InternalEssentialOCL.g:12825:1: rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ; |
| public final void rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12829:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:12830:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:12830:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:12831:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3" |
| // InternalEssentialOCL.g:12840:1: rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 : ( ruleExpCS ) ; |
| public final void rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12844:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:12845:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:12845:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:12846:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3" |
| |
| |
| // $ANTLR start "rule__NumberLiteralExpCS__SymbolAssignment" |
| // InternalEssentialOCL.g:12855:1: rule__NumberLiteralExpCS__SymbolAssignment : ( ruleNUMBER_LITERAL ) ; |
| public final void rule__NumberLiteralExpCS__SymbolAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12859:1: ( ( ruleNUMBER_LITERAL ) ) |
| // InternalEssentialOCL.g:12860:1: ( ruleNUMBER_LITERAL ) |
| { |
| // InternalEssentialOCL.g:12860:1: ( ruleNUMBER_LITERAL ) |
| // InternalEssentialOCL.g:12861:1: ruleNUMBER_LITERAL |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumberLiteralExpCSAccess().getSymbolNUMBER_LITERALParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNUMBER_LITERAL(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumberLiteralExpCSAccess().getSymbolNUMBER_LITERALParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumberLiteralExpCS__SymbolAssignment" |
| |
| |
| // $ANTLR start "rule__StringLiteralExpCS__SegmentsAssignment" |
| // InternalEssentialOCL.g:12870:1: rule__StringLiteralExpCS__SegmentsAssignment : ( ruleStringLiteral ) ; |
| public final void rule__StringLiteralExpCS__SegmentsAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12874:1: ( ( ruleStringLiteral ) ) |
| // InternalEssentialOCL.g:12875:1: ( ruleStringLiteral ) |
| { |
| // InternalEssentialOCL.g:12875:1: ( ruleStringLiteral ) |
| // InternalEssentialOCL.g:12876:1: ruleStringLiteral |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsStringLiteralParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleStringLiteral(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringLiteralExpCSAccess().getSegmentsStringLiteralParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringLiteralExpCS__SegmentsAssignment" |
| |
| |
| // $ANTLR start "rule__BooleanLiteralExpCS__SymbolAssignment_0" |
| // InternalEssentialOCL.g:12885:1: rule__BooleanLiteralExpCS__SymbolAssignment_0 : ( ( 'true' ) ) ; |
| public final void rule__BooleanLiteralExpCS__SymbolAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12889:1: ( ( ( 'true' ) ) ) |
| // InternalEssentialOCL.g:12890:1: ( ( 'true' ) ) |
| { |
| // InternalEssentialOCL.g:12890:1: ( ( 'true' ) ) |
| // InternalEssentialOCL.g:12891:1: ( 'true' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0()); |
| } |
| // InternalEssentialOCL.g:12892:1: ( 'true' ) |
| // InternalEssentialOCL.g:12893:1: 'true' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0()); |
| } |
| match(input,84,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__BooleanLiteralExpCS__SymbolAssignment_0" |
| |
| |
| // $ANTLR start "rule__BooleanLiteralExpCS__SymbolAssignment_1" |
| // InternalEssentialOCL.g:12908:1: rule__BooleanLiteralExpCS__SymbolAssignment_1 : ( ( 'false' ) ) ; |
| public final void rule__BooleanLiteralExpCS__SymbolAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12912:1: ( ( ( 'false' ) ) ) |
| // InternalEssentialOCL.g:12913:1: ( ( 'false' ) ) |
| { |
| // InternalEssentialOCL.g:12913:1: ( ( 'false' ) ) |
| // InternalEssentialOCL.g:12914:1: ( 'false' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0()); |
| } |
| // InternalEssentialOCL.g:12915:1: ( 'false' ) |
| // InternalEssentialOCL.g:12916:1: 'false' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0()); |
| } |
| match(input,85,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__BooleanLiteralExpCS__SymbolAssignment_1" |
| |
| |
| // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1" |
| // InternalEssentialOCL.g:12931:1: rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 : ( ruleMultiplicityCS ) ; |
| public final void rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12935:1: ( ( ruleMultiplicityCS ) ) |
| // InternalEssentialOCL.g:12936:1: ( ruleMultiplicityCS ) |
| { |
| // InternalEssentialOCL.g:12936:1: ( ruleMultiplicityCS ) |
| // InternalEssentialOCL.g:12937:1: ruleMultiplicityCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMultiplicityCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1" |
| |
| |
| // $ANTLR start "rule__TypeLiteralExpCS__OwnedTypeAssignment" |
| // InternalEssentialOCL.g:12946:1: rule__TypeLiteralExpCS__OwnedTypeAssignment : ( ruleTypeLiteralWithMultiplicityCS ) ; |
| public final void rule__TypeLiteralExpCS__OwnedTypeAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12950:1: ( ( ruleTypeLiteralWithMultiplicityCS ) ) |
| // InternalEssentialOCL.g:12951:1: ( ruleTypeLiteralWithMultiplicityCS ) |
| { |
| // InternalEssentialOCL.g:12951:1: ( ruleTypeLiteralWithMultiplicityCS ) |
| // InternalEssentialOCL.g:12952:1: ruleTypeLiteralWithMultiplicityCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeTypeLiteralWithMultiplicityCSParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeLiteralWithMultiplicityCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeTypeLiteralWithMultiplicityCSParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeLiteralExpCS__OwnedTypeAssignment" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__OwnedPathNameAssignment_0" |
| // InternalEssentialOCL.g:12961:1: rule__TypeNameExpCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ; |
| public final void rule__TypeNameExpCS__OwnedPathNameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12965:1: ( ( rulePathNameCS ) ) |
| // InternalEssentialOCL.g:12966:1: ( rulePathNameCS ) |
| { |
| // InternalEssentialOCL.g:12966:1: ( rulePathNameCS ) |
| // InternalEssentialOCL.g:12967:1: rulePathNameCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePathNameCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__OwnedPathNameAssignment_0" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0" |
| // InternalEssentialOCL.g:12976:1: rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 : ( ruleCurlyBracketedClauseCS ) ; |
| public final void rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12980:1: ( ( ruleCurlyBracketedClauseCS ) ) |
| // InternalEssentialOCL.g:12981:1: ( ruleCurlyBracketedClauseCS ) |
| { |
| // InternalEssentialOCL.g:12981:1: ( ruleCurlyBracketedClauseCS ) |
| // InternalEssentialOCL.g:12982:1: ruleCurlyBracketedClauseCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_1_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCurlyBracketedClauseCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0" |
| |
| |
| // $ANTLR start "rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1" |
| // InternalEssentialOCL.g:12991:1: rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 : ( ruleExpCS ) ; |
| public final void rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:12995:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:12996:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:12996:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:12997:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardExpCSParserRuleCall_1_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardExpCSParserRuleCall_1_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1" |
| |
| |
| // $ANTLR start "rule__TypeExpCS__OwnedMultiplicityAssignment_1" |
| // InternalEssentialOCL.g:13006:1: rule__TypeExpCS__OwnedMultiplicityAssignment_1 : ( ruleMultiplicityCS ) ; |
| public final void rule__TypeExpCS__OwnedMultiplicityAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13010:1: ( ( ruleMultiplicityCS ) ) |
| // InternalEssentialOCL.g:13011:1: ( ruleMultiplicityCS ) |
| { |
| // InternalEssentialOCL.g:13011:1: ( ruleMultiplicityCS ) |
| // InternalEssentialOCL.g:13012:1: ruleMultiplicityCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMultiplicityCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeExpCS__OwnedMultiplicityAssignment_1" |
| |
| |
| // $ANTLR start "rule__ExpCS__NameAssignment_0_1_1" |
| // InternalEssentialOCL.g:13021:1: rule__ExpCS__NameAssignment_0_1_1 : ( ruleBinaryOperatorName ) ; |
| public final void rule__ExpCS__NameAssignment_0_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13025:1: ( ( ruleBinaryOperatorName ) ) |
| // InternalEssentialOCL.g:13026:1: ( ruleBinaryOperatorName ) |
| { |
| // InternalEssentialOCL.g:13026:1: ( ruleBinaryOperatorName ) |
| // InternalEssentialOCL.g:13027:1: ruleBinaryOperatorName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSAccess().getNameBinaryOperatorNameParserRuleCall_0_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleBinaryOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpCSAccess().getNameBinaryOperatorNameParserRuleCall_0_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__NameAssignment_0_1_1" |
| |
| |
| // $ANTLR start "rule__ExpCS__OwnedRightAssignment_0_1_2" |
| // InternalEssentialOCL.g:13036:1: rule__ExpCS__OwnedRightAssignment_0_1_2 : ( ruleExpCS ) ; |
| public final void rule__ExpCS__OwnedRightAssignment_0_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13040:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13041:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13041:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13042:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSAccess().getOwnedRightExpCSParserRuleCall_0_1_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getExpCSAccess().getOwnedRightExpCSParserRuleCall_0_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExpCS__OwnedRightAssignment_0_1_2" |
| |
| |
| // $ANTLR start "rule__PrefixedLetExpCS__NameAssignment_0_1" |
| // InternalEssentialOCL.g:13051:1: rule__PrefixedLetExpCS__NameAssignment_0_1 : ( ruleUnaryOperatorName ) ; |
| public final void rule__PrefixedLetExpCS__NameAssignment_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13055:1: ( ( ruleUnaryOperatorName ) ) |
| // InternalEssentialOCL.g:13056:1: ( ruleUnaryOperatorName ) |
| { |
| // InternalEssentialOCL.g:13056:1: ( ruleUnaryOperatorName ) |
| // InternalEssentialOCL.g:13057:1: ruleUnaryOperatorName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedLetExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnaryOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedLetExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedLetExpCS__NameAssignment_0_1" |
| |
| |
| // $ANTLR start "rule__PrefixedLetExpCS__OwnedRightAssignment_0_2" |
| // InternalEssentialOCL.g:13066:1: rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 : ( rulePrefixedLetExpCS ) ; |
| public final void rule__PrefixedLetExpCS__OwnedRightAssignment_0_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13070:1: ( ( rulePrefixedLetExpCS ) ) |
| // InternalEssentialOCL.g:13071:1: ( rulePrefixedLetExpCS ) |
| { |
| // InternalEssentialOCL.g:13071:1: ( rulePrefixedLetExpCS ) |
| // InternalEssentialOCL.g:13072:1: rulePrefixedLetExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightPrefixedLetExpCSParserRuleCall_0_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePrefixedLetExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightPrefixedLetExpCSParserRuleCall_0_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedLetExpCS__OwnedRightAssignment_0_2" |
| |
| |
| // $ANTLR start "rule__PrefixedPrimaryExpCS__NameAssignment_0_1" |
| // InternalEssentialOCL.g:13081:1: rule__PrefixedPrimaryExpCS__NameAssignment_0_1 : ( ruleUnaryOperatorName ) ; |
| public final void rule__PrefixedPrimaryExpCS__NameAssignment_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13085:1: ( ( ruleUnaryOperatorName ) ) |
| // InternalEssentialOCL.g:13086:1: ( ruleUnaryOperatorName ) |
| { |
| // InternalEssentialOCL.g:13086:1: ( ruleUnaryOperatorName ) |
| // InternalEssentialOCL.g:13087:1: ruleUnaryOperatorName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnaryOperatorName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedPrimaryExpCS__NameAssignment_0_1" |
| |
| |
| // $ANTLR start "rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2" |
| // InternalEssentialOCL.g:13096:1: rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 : ( rulePrefixedPrimaryExpCS ) ; |
| public final void rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13100:1: ( ( rulePrefixedPrimaryExpCS ) ) |
| // InternalEssentialOCL.g:13101:1: ( rulePrefixedPrimaryExpCS ) |
| { |
| // InternalEssentialOCL.g:13101:1: ( rulePrefixedPrimaryExpCS ) |
| // InternalEssentialOCL.g:13102:1: rulePrefixedPrimaryExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightPrefixedPrimaryExpCSParserRuleCall_0_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePrefixedPrimaryExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightPrefixedPrimaryExpCSParserRuleCall_0_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2" |
| |
| |
| // $ANTLR start "rule__NameExpCS__OwnedPathNameAssignment_0" |
| // InternalEssentialOCL.g:13111:1: rule__NameExpCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ; |
| public final void rule__NameExpCS__OwnedPathNameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13115:1: ( ( rulePathNameCS ) ) |
| // InternalEssentialOCL.g:13116:1: ( rulePathNameCS ) |
| { |
| // InternalEssentialOCL.g:13116:1: ( rulePathNameCS ) |
| // InternalEssentialOCL.g:13117:1: rulePathNameCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePathNameCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__OwnedPathNameAssignment_0" |
| |
| |
| // $ANTLR start "rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1" |
| // InternalEssentialOCL.g:13126:1: rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 : ( ruleSquareBracketedClauseCS ) ; |
| public final void rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13130:1: ( ( ruleSquareBracketedClauseCS ) ) |
| // InternalEssentialOCL.g:13131:1: ( ruleSquareBracketedClauseCS ) |
| { |
| // InternalEssentialOCL.g:13131:1: ( ruleSquareBracketedClauseCS ) |
| // InternalEssentialOCL.g:13132:1: ruleSquareBracketedClauseCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesSquareBracketedClauseCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleSquareBracketedClauseCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesSquareBracketedClauseCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1" |
| |
| |
| // $ANTLR start "rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2" |
| // InternalEssentialOCL.g:13141:1: rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 : ( ruleRoundBracketedClauseCS ) ; |
| public final void rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13145:1: ( ( ruleRoundBracketedClauseCS ) ) |
| // InternalEssentialOCL.g:13146:1: ( ruleRoundBracketedClauseCS ) |
| { |
| // InternalEssentialOCL.g:13146:1: ( ruleRoundBracketedClauseCS ) |
| // InternalEssentialOCL.g:13147:1: ruleRoundBracketedClauseCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleRoundBracketedClauseCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2" |
| |
| |
| // $ANTLR start "rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3" |
| // InternalEssentialOCL.g:13156:1: rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 : ( ruleCurlyBracketedClauseCS ) ; |
| public final void rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13160:1: ( ( ruleCurlyBracketedClauseCS ) ) |
| // InternalEssentialOCL.g:13161:1: ( ruleCurlyBracketedClauseCS ) |
| { |
| // InternalEssentialOCL.g:13161:1: ( ruleCurlyBracketedClauseCS ) |
| // InternalEssentialOCL.g:13162:1: ruleCurlyBracketedClauseCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCurlyBracketedClauseCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3" |
| |
| |
| // $ANTLR start "rule__NameExpCS__IsPreAssignment_4_0" |
| // InternalEssentialOCL.g:13171:1: rule__NameExpCS__IsPreAssignment_4_0 : ( ( '@' ) ) ; |
| public final void rule__NameExpCS__IsPreAssignment_4_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13175:1: ( ( ( '@' ) ) ) |
| // InternalEssentialOCL.g:13176:1: ( ( '@' ) ) |
| { |
| // InternalEssentialOCL.g:13176:1: ( ( '@' ) ) |
| // InternalEssentialOCL.g:13177:1: ( '@' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0()); |
| } |
| // InternalEssentialOCL.g:13178:1: ( '@' ) |
| // InternalEssentialOCL.g:13179:1: '@' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0()); |
| } |
| match(input,86,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NameExpCS__IsPreAssignment_4_0" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0" |
| // InternalEssentialOCL.g:13194:1: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 : ( ruleShadowPartCS ) ; |
| public final void rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13198:1: ( ( ruleShadowPartCS ) ) |
| // InternalEssentialOCL.g:13199:1: ( ruleShadowPartCS ) |
| { |
| // InternalEssentialOCL.g:13199:1: ( ruleShadowPartCS ) |
| // InternalEssentialOCL.g:13200:1: ruleShadowPartCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleShadowPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0" |
| |
| |
| // $ANTLR start "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1" |
| // InternalEssentialOCL.g:13209:1: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 : ( ruleShadowPartCS ) ; |
| public final void rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13213:1: ( ( ruleShadowPartCS ) ) |
| // InternalEssentialOCL.g:13214:1: ( ruleShadowPartCS ) |
| { |
| // InternalEssentialOCL.g:13214:1: ( ruleShadowPartCS ) |
| // InternalEssentialOCL.g:13215:1: ruleShadowPartCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleShadowPartCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0" |
| // InternalEssentialOCL.g:13224:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 : ( ruleNavigatingArgCS ) ; |
| public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13228:1: ( ( ruleNavigatingArgCS ) ) |
| // InternalEssentialOCL.g:13229:1: ( ruleNavigatingArgCS ) |
| { |
| // InternalEssentialOCL.g:13229:1: ( ruleNavigatingArgCS ) |
| // InternalEssentialOCL.g:13230:1: ruleNavigatingArgCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingArgCSParserRuleCall_2_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNavigatingArgCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingArgCSParserRuleCall_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0" |
| |
| |
| // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1" |
| // InternalEssentialOCL.g:13239:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) ) ; |
| public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13243:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) ) ) |
| // InternalEssentialOCL.g:13244:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) ) |
| { |
| // InternalEssentialOCL.g:13244:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) ) |
| // InternalEssentialOCL.g:13245:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAlternatives_2_1_0()); |
| } |
| // InternalEssentialOCL.g:13246:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) |
| // InternalEssentialOCL.g:13246:2: rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAlternatives_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__OwnedTermsAssignment_1" |
| // InternalEssentialOCL.g:13255:1: rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 : ( ruleExpCS ) ; |
| public final void rule__SquareBracketedClauseCS__OwnedTermsAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13259:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13260:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13260:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13261:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__OwnedTermsAssignment_1" |
| |
| |
| // $ANTLR start "rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1" |
| // InternalEssentialOCL.g:13270:1: rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 : ( ruleExpCS ) ; |
| public final void rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13274:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13275:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13275:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13276:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0" |
| // InternalEssentialOCL.g:13285:1: rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 : ( ruleNavigatingArgExpCS ) ; |
| public final void rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13289:1: ( ( ruleNavigatingArgExpCS ) ) |
| // InternalEssentialOCL.g:13290:1: ( ruleNavigatingArgExpCS ) |
| { |
| // InternalEssentialOCL.g:13290:1: ( ruleNavigatingArgExpCS ) |
| // InternalEssentialOCL.g:13291:1: ruleNavigatingArgExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_0_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNavigatingArgExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_0_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1" |
| // InternalEssentialOCL.g:13300:1: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 : ( ruleCoIteratorVariableCS ) ; |
| public final void rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13304:1: ( ( ruleCoIteratorVariableCS ) ) |
| // InternalEssentialOCL.g:13305:1: ( ruleCoIteratorVariableCS ) |
| { |
| // InternalEssentialOCL.g:13305:1: ( ruleCoIteratorVariableCS ) |
| // InternalEssentialOCL.g:13306:1: ruleCoIteratorVariableCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_0_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCoIteratorVariableCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1" |
| // InternalEssentialOCL.g:13315:1: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 : ( ruleExpCS ) ; |
| public final void rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13319:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13320:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13320:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13321:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_0_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_0_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1" |
| // InternalEssentialOCL.g:13330:1: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 : ( ruleTypeExpCS ) ; |
| public final void rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13334:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:13335:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:13335:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:13336:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1" |
| // InternalEssentialOCL.g:13345:1: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 : ( ruleCoIteratorVariableCS ) ; |
| public final void rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13349:1: ( ( ruleCoIteratorVariableCS ) ) |
| // InternalEssentialOCL.g:13350:1: ( ruleCoIteratorVariableCS ) |
| { |
| // InternalEssentialOCL.g:13350:1: ( ruleCoIteratorVariableCS ) |
| // InternalEssentialOCL.g:13351:1: ruleCoIteratorVariableCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_1_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCoIteratorVariableCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_1_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1" |
| // InternalEssentialOCL.g:13360:1: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 : ( ruleExpCS ) ; |
| public final void rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13364:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13365:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13365:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13366:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_1_3_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_1_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1" |
| // InternalEssentialOCL.g:13375:1: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 : ( ruleTypeExpCS ) ; |
| public final void rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13379:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:13380:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:13380:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:13381:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_2_0_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_2_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1" |
| // InternalEssentialOCL.g:13390:1: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 : ( ruleCoIteratorVariableCS ) ; |
| public final void rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13394:1: ( ( ruleCoIteratorVariableCS ) ) |
| // InternalEssentialOCL.g:13395:1: ( ruleCoIteratorVariableCS ) |
| { |
| // InternalEssentialOCL.g:13395:1: ( ruleCoIteratorVariableCS ) |
| // InternalEssentialOCL.g:13396:1: ruleCoIteratorVariableCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_2_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCoIteratorVariableCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3" |
| // InternalEssentialOCL.g:13405:1: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 : ( ruleExpCS ) ; |
| public final void rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13409:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13410:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13410:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13411:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_2_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_2_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3" |
| |
| |
| // $ANTLR start "rule__NavigatingArgCS__OwnedTypeAssignment_1_1" |
| // InternalEssentialOCL.g:13420:1: rule__NavigatingArgCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ; |
| public final void rule__NavigatingArgCS__OwnedTypeAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13424:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:13425:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:13425:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:13426:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingArgCS__OwnedTypeAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__PrefixAssignment_0" |
| // InternalEssentialOCL.g:13435:1: rule__NavigatingBarArgCS__PrefixAssignment_0 : ( ( '|' ) ) ; |
| public final void rule__NavigatingBarArgCS__PrefixAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13439:1: ( ( ( '|' ) ) ) |
| // InternalEssentialOCL.g:13440:1: ( ( '|' ) ) |
| { |
| // InternalEssentialOCL.g:13440:1: ( ( '|' ) ) |
| // InternalEssentialOCL.g:13441:1: ( '|' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0()); |
| } |
| // InternalEssentialOCL.g:13442:1: ( '|' ) |
| // InternalEssentialOCL.g:13443:1: '|' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0()); |
| } |
| match(input,87,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__PrefixAssignment_0" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1" |
| // InternalEssentialOCL.g:13458:1: rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ; |
| public final void rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13462:1: ( ( ruleNavigatingArgExpCS ) ) |
| // InternalEssentialOCL.g:13463:1: ( ruleNavigatingArgExpCS ) |
| { |
| // InternalEssentialOCL.g:13463:1: ( ruleNavigatingArgExpCS ) |
| // InternalEssentialOCL.g:13464:1: ruleNavigatingArgExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNavigatingArgExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1" |
| // InternalEssentialOCL.g:13473:1: rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ; |
| public final void rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13477:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:13478:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:13478:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:13479:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1" |
| // InternalEssentialOCL.g:13488:1: rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 : ( ruleExpCS ) ; |
| public final void rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13492:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13493:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13493:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13494:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__PrefixAssignment_0" |
| // InternalEssentialOCL.g:13503:1: rule__NavigatingCommaArgCS__PrefixAssignment_0 : ( ( ',' ) ) ; |
| public final void rule__NavigatingCommaArgCS__PrefixAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13507:1: ( ( ( ',' ) ) ) |
| // InternalEssentialOCL.g:13508:1: ( ( ',' ) ) |
| { |
| // InternalEssentialOCL.g:13508:1: ( ( ',' ) ) |
| // InternalEssentialOCL.g:13509:1: ( ',' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0()); |
| } |
| // InternalEssentialOCL.g:13510:1: ( ',' ) |
| // InternalEssentialOCL.g:13511:1: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0()); |
| } |
| match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__PrefixAssignment_0" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1" |
| // InternalEssentialOCL.g:13526:1: rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ; |
| public final void rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13530:1: ( ( ruleNavigatingArgExpCS ) ) |
| // InternalEssentialOCL.g:13531:1: ( ruleNavigatingArgExpCS ) |
| { |
| // InternalEssentialOCL.g:13531:1: ( ruleNavigatingArgExpCS ) |
| // InternalEssentialOCL.g:13532:1: ruleNavigatingArgExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNavigatingArgExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1" |
| // InternalEssentialOCL.g:13541:1: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 : ( ruleCoIteratorVariableCS ) ; |
| public final void rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13545:1: ( ( ruleCoIteratorVariableCS ) ) |
| // InternalEssentialOCL.g:13546:1: ( ruleCoIteratorVariableCS ) |
| { |
| // InternalEssentialOCL.g:13546:1: ( ruleCoIteratorVariableCS ) |
| // InternalEssentialOCL.g:13547:1: ruleCoIteratorVariableCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_0_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCoIteratorVariableCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1" |
| // InternalEssentialOCL.g:13556:1: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 : ( ruleExpCS ) ; |
| public final void rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13560:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13561:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13561:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13562:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_0_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_0_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1" |
| // InternalEssentialOCL.g:13571:1: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 : ( ruleTypeExpCS ) ; |
| public final void rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13575:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:13576:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:13576:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:13577:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1" |
| // InternalEssentialOCL.g:13586:1: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 : ( ruleCoIteratorVariableCS ) ; |
| public final void rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13590:1: ( ( ruleCoIteratorVariableCS ) ) |
| // InternalEssentialOCL.g:13591:1: ( ruleCoIteratorVariableCS ) |
| { |
| // InternalEssentialOCL.g:13591:1: ( ruleCoIteratorVariableCS ) |
| // InternalEssentialOCL.g:13592:1: ruleCoIteratorVariableCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_1_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCoIteratorVariableCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_1_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1" |
| // InternalEssentialOCL.g:13601:1: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 : ( ruleExpCS ) ; |
| public final void rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13605:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13606:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13606:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13607:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_1_3_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_1_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1" |
| // InternalEssentialOCL.g:13616:1: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 : ( ruleTypeExpCS ) ; |
| public final void rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13620:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:13621:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:13621:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:13622:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_2_0_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_2_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1" |
| // InternalEssentialOCL.g:13631:1: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 : ( ruleCoIteratorVariableCS ) ; |
| public final void rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13635:1: ( ( ruleCoIteratorVariableCS ) ) |
| // InternalEssentialOCL.g:13636:1: ( ruleCoIteratorVariableCS ) |
| { |
| // InternalEssentialOCL.g:13636:1: ( ruleCoIteratorVariableCS ) |
| // InternalEssentialOCL.g:13637:1: ruleCoIteratorVariableCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_2_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCoIteratorVariableCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1" |
| |
| |
| // $ANTLR start "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3" |
| // InternalEssentialOCL.g:13646:1: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 : ( ruleExpCS ) ; |
| public final void rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13650:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13651:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13651:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13652:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__PrefixAssignment_0" |
| // InternalEssentialOCL.g:13661:1: rule__NavigatingSemiArgCS__PrefixAssignment_0 : ( ( ';' ) ) ; |
| public final void rule__NavigatingSemiArgCS__PrefixAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13665:1: ( ( ( ';' ) ) ) |
| // InternalEssentialOCL.g:13666:1: ( ( ';' ) ) |
| { |
| // InternalEssentialOCL.g:13666:1: ( ( ';' ) ) |
| // InternalEssentialOCL.g:13667:1: ( ';' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0()); |
| } |
| // InternalEssentialOCL.g:13668:1: ( ';' ) |
| // InternalEssentialOCL.g:13669:1: ';' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0()); |
| } |
| match(input,88,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__PrefixAssignment_0" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1" |
| // InternalEssentialOCL.g:13684:1: rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ; |
| public final void rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13688:1: ( ( ruleNavigatingArgExpCS ) ) |
| // InternalEssentialOCL.g:13689:1: ( ruleNavigatingArgExpCS ) |
| { |
| // InternalEssentialOCL.g:13689:1: ( ruleNavigatingArgExpCS ) |
| // InternalEssentialOCL.g:13690:1: ruleNavigatingArgExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNavigatingArgExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1" |
| // InternalEssentialOCL.g:13699:1: rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ; |
| public final void rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13703:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:13704:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:13704:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:13705:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1" |
| // InternalEssentialOCL.g:13714:1: rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 : ( ruleExpCS ) ; |
| public final void rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13718:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13719:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13719:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13720:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1" |
| |
| |
| // $ANTLR start "rule__CoIteratorVariableCS__NameAssignment_0" |
| // InternalEssentialOCL.g:13729:1: rule__CoIteratorVariableCS__NameAssignment_0 : ( ruleUnrestrictedName ) ; |
| public final void rule__CoIteratorVariableCS__NameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13733:1: ( ( ruleUnrestrictedName ) ) |
| // InternalEssentialOCL.g:13734:1: ( ruleUnrestrictedName ) |
| { |
| // InternalEssentialOCL.g:13734:1: ( ruleUnrestrictedName ) |
| // InternalEssentialOCL.g:13735:1: ruleUnrestrictedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCoIteratorVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCoIteratorVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CoIteratorVariableCS__NameAssignment_0" |
| |
| |
| // $ANTLR start "rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1" |
| // InternalEssentialOCL.g:13744:1: rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ; |
| public final void rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13748:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:13749:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:13749:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:13750:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__IfExpCS__OwnedConditionAssignment_1" |
| // InternalEssentialOCL.g:13759:1: rule__IfExpCS__OwnedConditionAssignment_1 : ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) ) ; |
| public final void rule__IfExpCS__OwnedConditionAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13763:1: ( ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) ) ) |
| // InternalEssentialOCL.g:13764:1: ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) ) |
| { |
| // InternalEssentialOCL.g:13764:1: ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) ) |
| // InternalEssentialOCL.g:13765:1: ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getOwnedConditionAlternatives_1_0()); |
| } |
| // InternalEssentialOCL.g:13766:1: ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) |
| // InternalEssentialOCL.g:13766:2: rule__IfExpCS__OwnedConditionAlternatives_1_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__IfExpCS__OwnedConditionAlternatives_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getOwnedConditionAlternatives_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__OwnedConditionAssignment_1" |
| |
| |
| // $ANTLR start "rule__IfExpCS__OwnedThenExpressionAssignment_3" |
| // InternalEssentialOCL.g:13775:1: rule__IfExpCS__OwnedThenExpressionAssignment_3 : ( ruleExpCS ) ; |
| public final void rule__IfExpCS__OwnedThenExpressionAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13779:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13780:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13780:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13781:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__OwnedThenExpressionAssignment_3" |
| |
| |
| // $ANTLR start "rule__IfExpCS__OwnedIfThenExpressionsAssignment_4" |
| // InternalEssentialOCL.g:13790:1: rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 : ( ruleElseIfThenExpCS ) ; |
| public final void rule__IfExpCS__OwnedIfThenExpressionsAssignment_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13794:1: ( ( ruleElseIfThenExpCS ) ) |
| // InternalEssentialOCL.g:13795:1: ( ruleElseIfThenExpCS ) |
| { |
| // InternalEssentialOCL.g:13795:1: ( ruleElseIfThenExpCS ) |
| // InternalEssentialOCL.g:13796:1: ruleElseIfThenExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsElseIfThenExpCSParserRuleCall_4_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleElseIfThenExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsElseIfThenExpCSParserRuleCall_4_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__OwnedIfThenExpressionsAssignment_4" |
| |
| |
| // $ANTLR start "rule__IfExpCS__OwnedElseExpressionAssignment_6" |
| // InternalEssentialOCL.g:13805:1: rule__IfExpCS__OwnedElseExpressionAssignment_6 : ( ruleExpCS ) ; |
| public final void rule__IfExpCS__OwnedElseExpressionAssignment_6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13809:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13810:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13810:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13811:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionExpCSParserRuleCall_6_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionExpCSParserRuleCall_6_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IfExpCS__OwnedElseExpressionAssignment_6" |
| |
| |
| // $ANTLR start "rule__ElseIfThenExpCS__OwnedConditionAssignment_1" |
| // InternalEssentialOCL.g:13820:1: rule__ElseIfThenExpCS__OwnedConditionAssignment_1 : ( ruleExpCS ) ; |
| public final void rule__ElseIfThenExpCS__OwnedConditionAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13824:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13825:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13825:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13826:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ElseIfThenExpCS__OwnedConditionAssignment_1" |
| |
| |
| // $ANTLR start "rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3" |
| // InternalEssentialOCL.g:13835:1: rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 : ( ruleExpCS ) ; |
| public final void rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13839:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13840:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13840:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13841:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3" |
| |
| |
| // $ANTLR start "rule__LetExpCS__OwnedVariablesAssignment_1" |
| // InternalEssentialOCL.g:13850:1: rule__LetExpCS__OwnedVariablesAssignment_1 : ( ruleLetVariableCS ) ; |
| public final void rule__LetExpCS__OwnedVariablesAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13854:1: ( ( ruleLetVariableCS ) ) |
| // InternalEssentialOCL.g:13855:1: ( ruleLetVariableCS ) |
| { |
| // InternalEssentialOCL.g:13855:1: ( ruleLetVariableCS ) |
| // InternalEssentialOCL.g:13856:1: ruleLetVariableCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLetVariableCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__OwnedVariablesAssignment_1" |
| |
| |
| // $ANTLR start "rule__LetExpCS__OwnedVariablesAssignment_2_1" |
| // InternalEssentialOCL.g:13865:1: rule__LetExpCS__OwnedVariablesAssignment_2_1 : ( ruleLetVariableCS ) ; |
| public final void rule__LetExpCS__OwnedVariablesAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13869:1: ( ( ruleLetVariableCS ) ) |
| // InternalEssentialOCL.g:13870:1: ( ruleLetVariableCS ) |
| { |
| // InternalEssentialOCL.g:13870:1: ( ruleLetVariableCS ) |
| // InternalEssentialOCL.g:13871:1: ruleLetVariableCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLetVariableCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__OwnedVariablesAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__LetExpCS__OwnedInExpressionAssignment_4" |
| // InternalEssentialOCL.g:13880:1: rule__LetExpCS__OwnedInExpressionAssignment_4 : ( ruleExpCS ) ; |
| public final void rule__LetExpCS__OwnedInExpressionAssignment_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13884:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13885:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13885:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13886:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetExpCSAccess().getOwnedInExpressionExpCSParserRuleCall_4_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetExpCSAccess().getOwnedInExpressionExpCSParserRuleCall_4_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetExpCS__OwnedInExpressionAssignment_4" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__NameAssignment_0" |
| // InternalEssentialOCL.g:13895:1: rule__LetVariableCS__NameAssignment_0 : ( ruleUnrestrictedName ) ; |
| public final void rule__LetVariableCS__NameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13899:1: ( ( ruleUnrestrictedName ) ) |
| // InternalEssentialOCL.g:13900:1: ( ruleUnrestrictedName ) |
| { |
| // InternalEssentialOCL.g:13900:1: ( ruleUnrestrictedName ) |
| // InternalEssentialOCL.g:13901:1: ruleUnrestrictedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__NameAssignment_0" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1" |
| // InternalEssentialOCL.g:13910:1: rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 : ( ruleRoundBracketedClauseCS ) ; |
| public final void rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13914:1: ( ( ruleRoundBracketedClauseCS ) ) |
| // InternalEssentialOCL.g:13915:1: ( ruleRoundBracketedClauseCS ) |
| { |
| // InternalEssentialOCL.g:13915:1: ( ruleRoundBracketedClauseCS ) |
| // InternalEssentialOCL.g:13916:1: ruleRoundBracketedClauseCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleRoundBracketedClauseCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__OwnedTypeAssignment_2_1" |
| // InternalEssentialOCL.g:13925:1: rule__LetVariableCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ; |
| public final void rule__LetVariableCS__OwnedTypeAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13929:1: ( ( ruleTypeExpCS ) ) |
| // InternalEssentialOCL.g:13930:1: ( ruleTypeExpCS ) |
| { |
| // InternalEssentialOCL.g:13930:1: ( ruleTypeExpCS ) |
| // InternalEssentialOCL.g:13931:1: ruleTypeExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__OwnedTypeAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__LetVariableCS__OwnedInitExpressionAssignment_4" |
| // InternalEssentialOCL.g:13940:1: rule__LetVariableCS__OwnedInitExpressionAssignment_4 : ( ruleExpCS ) ; |
| public final void rule__LetVariableCS__OwnedInitExpressionAssignment_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13944:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13945:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13945:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13946:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionExpCSParserRuleCall_4_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionExpCSParserRuleCall_4_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LetVariableCS__OwnedInitExpressionAssignment_4" |
| |
| |
| // $ANTLR start "rule__NestedExpCS__OwnedExpressionAssignment_1" |
| // InternalEssentialOCL.g:13955:1: rule__NestedExpCS__OwnedExpressionAssignment_1 : ( ruleExpCS ) ; |
| public final void rule__NestedExpCS__OwnedExpressionAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13959:1: ( ( ruleExpCS ) ) |
| // InternalEssentialOCL.g:13960:1: ( ruleExpCS ) |
| { |
| // InternalEssentialOCL.g:13960:1: ( ruleExpCS ) |
| // InternalEssentialOCL.g:13961:1: ruleExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedExpCSAccess().getOwnedExpressionExpCSParserRuleCall_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedExpCSAccess().getOwnedExpressionExpCSParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedExpCS__OwnedExpressionAssignment_1" |
| |
| |
| // $ANTLR start "rule__MultiplicityBoundsCS__LowerBoundAssignment_0" |
| // InternalEssentialOCL.g:13970:1: rule__MultiplicityBoundsCS__LowerBoundAssignment_0 : ( ruleLOWER ) ; |
| public final void rule__MultiplicityBoundsCS__LowerBoundAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13974:1: ( ( ruleLOWER ) ) |
| // InternalEssentialOCL.g:13975:1: ( ruleLOWER ) |
| { |
| // InternalEssentialOCL.g:13975:1: ( ruleLOWER ) |
| // InternalEssentialOCL.g:13976:1: ruleLOWER |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundLOWERParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleLOWER(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundLOWERParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityBoundsCS__LowerBoundAssignment_0" |
| |
| |
| // $ANTLR start "rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1" |
| // InternalEssentialOCL.g:13985:1: rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 : ( ruleUPPER ) ; |
| public final void rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:13989:1: ( ( ruleUPPER ) ) |
| // InternalEssentialOCL.g:13990:1: ( ruleUPPER ) |
| { |
| // InternalEssentialOCL.g:13990:1: ( ruleUPPER ) |
| // InternalEssentialOCL.g:13991:1: ruleUPPER |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundUPPERParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUPPER(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundUPPERParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__MultiplicityCS__IsNullFreeAssignment_2_1" |
| // InternalEssentialOCL.g:14000:1: rule__MultiplicityCS__IsNullFreeAssignment_2_1 : ( ( '|1' ) ) ; |
| public final void rule__MultiplicityCS__IsNullFreeAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14004:1: ( ( ( '|1' ) ) ) |
| // InternalEssentialOCL.g:14005:1: ( ( '|1' ) ) |
| { |
| // InternalEssentialOCL.g:14005:1: ( ( '|1' ) ) |
| // InternalEssentialOCL.g:14006:1: ( '|1' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0()); |
| } |
| // InternalEssentialOCL.g:14007:1: ( '|1' ) |
| // InternalEssentialOCL.g:14008:1: '|1' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0()); |
| } |
| match(input,89,FollowSets000.FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityCS__IsNullFreeAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__MultiplicityStringCS__StringBoundsAssignment" |
| // InternalEssentialOCL.g:14023:1: rule__MultiplicityStringCS__StringBoundsAssignment : ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) ) ; |
| public final void rule__MultiplicityStringCS__StringBoundsAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14027:1: ( ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) ) ) |
| // InternalEssentialOCL.g:14028:1: ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) ) |
| { |
| // InternalEssentialOCL.g:14028:1: ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) ) |
| // InternalEssentialOCL.g:14029:1: ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAlternatives_0()); |
| } |
| // InternalEssentialOCL.g:14030:1: ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) |
| // InternalEssentialOCL.g:14030:2: rule__MultiplicityStringCS__StringBoundsAlternatives_0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__MultiplicityStringCS__StringBoundsAlternatives_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAlternatives_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MultiplicityStringCS__StringBoundsAssignment" |
| |
| |
| // $ANTLR start "rule__PathNameCS__OwnedPathElementsAssignment_0" |
| // InternalEssentialOCL.g:14039:1: rule__PathNameCS__OwnedPathElementsAssignment_0 : ( ruleFirstPathElementCS ) ; |
| public final void rule__PathNameCS__OwnedPathElementsAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14043:1: ( ( ruleFirstPathElementCS ) ) |
| // InternalEssentialOCL.g:14044:1: ( ruleFirstPathElementCS ) |
| { |
| // InternalEssentialOCL.g:14044:1: ( ruleFirstPathElementCS ) |
| // InternalEssentialOCL.g:14045:1: ruleFirstPathElementCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsFirstPathElementCSParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleFirstPathElementCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsFirstPathElementCSParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PathNameCS__OwnedPathElementsAssignment_0" |
| |
| |
| // $ANTLR start "rule__PathNameCS__OwnedPathElementsAssignment_1_1" |
| // InternalEssentialOCL.g:14054:1: rule__PathNameCS__OwnedPathElementsAssignment_1_1 : ( ruleNextPathElementCS ) ; |
| public final void rule__PathNameCS__OwnedPathElementsAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14058:1: ( ( ruleNextPathElementCS ) ) |
| // InternalEssentialOCL.g:14059:1: ( ruleNextPathElementCS ) |
| { |
| // InternalEssentialOCL.g:14059:1: ( ruleNextPathElementCS ) |
| // InternalEssentialOCL.g:14060:1: ruleNextPathElementCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsNextPathElementCSParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleNextPathElementCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsNextPathElementCSParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PathNameCS__OwnedPathElementsAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__FirstPathElementCS__ReferredElementAssignment" |
| // InternalEssentialOCL.g:14071:1: rule__FirstPathElementCS__ReferredElementAssignment : ( ( ruleUnrestrictedName ) ) ; |
| public final void rule__FirstPathElementCS__ReferredElementAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14075:1: ( ( ( ruleUnrestrictedName ) ) ) |
| // InternalEssentialOCL.g:14076:1: ( ( ruleUnrestrictedName ) ) |
| { |
| // InternalEssentialOCL.g:14076:1: ( ( ruleUnrestrictedName ) ) |
| // InternalEssentialOCL.g:14077:1: ( ruleUnrestrictedName ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0()); |
| } |
| // InternalEssentialOCL.g:14078:1: ( ruleUnrestrictedName ) |
| // InternalEssentialOCL.g:14079:1: ruleUnrestrictedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__FirstPathElementCS__ReferredElementAssignment" |
| |
| |
| // $ANTLR start "rule__NextPathElementCS__ReferredElementAssignment" |
| // InternalEssentialOCL.g:14090:1: rule__NextPathElementCS__ReferredElementAssignment : ( ( ruleUnreservedName ) ) ; |
| public final void rule__NextPathElementCS__ReferredElementAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14094:1: ( ( ( ruleUnreservedName ) ) ) |
| // InternalEssentialOCL.g:14095:1: ( ( ruleUnreservedName ) ) |
| { |
| // InternalEssentialOCL.g:14095:1: ( ( ruleUnreservedName ) ) |
| // InternalEssentialOCL.g:14096:1: ( ruleUnreservedName ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementCrossReference_0()); |
| } |
| // InternalEssentialOCL.g:14097:1: ( ruleUnreservedName ) |
| // InternalEssentialOCL.g:14098:1: ruleUnreservedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementUnreservedNameParserRuleCall_0_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnreservedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementUnreservedNameParserRuleCall_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementCrossReference_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NextPathElementCS__ReferredElementAssignment" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0" |
| // InternalEssentialOCL.g:14109:1: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 : ( ruleTemplateParameterSubstitutionCS ) ; |
| public final void rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14113:1: ( ( ruleTemplateParameterSubstitutionCS ) ) |
| // InternalEssentialOCL.g:14114:1: ( ruleTemplateParameterSubstitutionCS ) |
| { |
| // InternalEssentialOCL.g:14114:1: ( ruleTemplateParameterSubstitutionCS ) |
| // InternalEssentialOCL.g:14115:1: ruleTemplateParameterSubstitutionCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTemplateParameterSubstitutionCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1" |
| // InternalEssentialOCL.g:14124:1: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 : ( ruleTemplateParameterSubstitutionCS ) ; |
| public final void rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14128:1: ( ( ruleTemplateParameterSubstitutionCS ) ) |
| // InternalEssentialOCL.g:14129:1: ( ruleTemplateParameterSubstitutionCS ) |
| { |
| // InternalEssentialOCL.g:14129:1: ( ruleTemplateParameterSubstitutionCS ) |
| // InternalEssentialOCL.g:14130:1: ruleTemplateParameterSubstitutionCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTemplateParameterSubstitutionCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__TemplateBindingCS__OwnedMultiplicityAssignment_2" |
| // InternalEssentialOCL.g:14139:1: rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 : ( ruleMultiplicityCS ) ; |
| public final void rule__TemplateBindingCS__OwnedMultiplicityAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14143:1: ( ( ruleMultiplicityCS ) ) |
| // InternalEssentialOCL.g:14144:1: ( ruleMultiplicityCS ) |
| { |
| // InternalEssentialOCL.g:14144:1: ( ruleMultiplicityCS ) |
| // InternalEssentialOCL.g:14145:1: ruleMultiplicityCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_2_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMultiplicityCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateBindingCS__OwnedMultiplicityAssignment_2" |
| |
| |
| // $ANTLR start "rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment" |
| // InternalEssentialOCL.g:14154:1: rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment : ( ruleTypeRefCS ) ; |
| public final void rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14158:1: ( ( ruleTypeRefCS ) ) |
| // InternalEssentialOCL.g:14159:1: ( ruleTypeRefCS ) |
| { |
| // InternalEssentialOCL.g:14159:1: ( ruleTypeRefCS ) |
| // InternalEssentialOCL.g:14160:1: ruleTypeRefCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterTypeRefCSParserRuleCall_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeRefCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterTypeRefCSParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__NameAssignment_0" |
| // InternalEssentialOCL.g:14171:1: rule__TypeParameterCS__NameAssignment_0 : ( ruleUnrestrictedName ) ; |
| public final void rule__TypeParameterCS__NameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14175:1: ( ( ruleUnrestrictedName ) ) |
| // InternalEssentialOCL.g:14176:1: ( ruleUnrestrictedName ) |
| { |
| // InternalEssentialOCL.g:14176:1: ( ruleUnrestrictedName ) |
| // InternalEssentialOCL.g:14177:1: ruleUnrestrictedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleUnrestrictedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__NameAssignment_0" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__OwnedExtendsAssignment_1_1" |
| // InternalEssentialOCL.g:14186:1: rule__TypeParameterCS__OwnedExtendsAssignment_1_1 : ( ruleTypedRefCS ) ; |
| public final void rule__TypeParameterCS__OwnedExtendsAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14190:1: ( ( ruleTypedRefCS ) ) |
| // InternalEssentialOCL.g:14191:1: ( ruleTypedRefCS ) |
| { |
| // InternalEssentialOCL.g:14191:1: ( ruleTypedRefCS ) |
| // InternalEssentialOCL.g:14192:1: ruleTypedRefCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypedRefCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__OwnedExtendsAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1" |
| // InternalEssentialOCL.g:14201:1: rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 : ( ruleTypedRefCS ) ; |
| public final void rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14205:1: ( ( ruleTypedRefCS ) ) |
| // InternalEssentialOCL.g:14206:1: ( ruleTypedRefCS ) |
| { |
| // InternalEssentialOCL.g:14206:1: ( ruleTypedRefCS ) |
| // InternalEssentialOCL.g:14207:1: ruleTypedRefCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypedRefCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__OwnedPathNameAssignment_0" |
| // InternalEssentialOCL.g:14216:1: rule__TypedTypeRefCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ; |
| public final void rule__TypedTypeRefCS__OwnedPathNameAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14220:1: ( ( rulePathNameCS ) ) |
| // InternalEssentialOCL.g:14221:1: ( rulePathNameCS ) |
| { |
| // InternalEssentialOCL.g:14221:1: ( rulePathNameCS ) |
| // InternalEssentialOCL.g:14222:1: rulePathNameCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| rulePathNameCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypedTypeRefCS__OwnedPathNameAssignment_0" |
| |
| |
| // $ANTLR start "rule__TypedTypeRefCS__OwnedBindingAssignment_1_1" |
| // InternalEssentialOCL.g:14231:1: rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 : ( ruleTemplateBindingCS ) ; |
| public final void rule__TypedTypeRefCS__OwnedBindingAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14235:1: ( ( ruleTemplateBindingCS ) ) |
| // InternalEssentialOCL.g:14236:1: ( ruleTemplateBindingCS ) |
| { |
| // InternalEssentialOCL.g:14236:1: ( ruleTemplateBindingCS ) |
| // InternalEssentialOCL.g:14237:1: ruleTemplateBindingCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingTemplateBindingCSParserRuleCall_1_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTemplateBindingCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingTemplateBindingCSParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TypedTypeRefCS__OwnedBindingAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1" |
| // InternalEssentialOCL.g:14246:1: rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 : ( ruleTypedRefCS ) ; |
| public final void rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalEssentialOCL.g:14250:1: ( ( ruleTypedRefCS ) ) |
| // InternalEssentialOCL.g:14251:1: ( ruleTypedRefCS ) |
| { |
| // InternalEssentialOCL.g:14251:1: ( ruleTypedRefCS ) |
| // InternalEssentialOCL.g:14252:1: ruleTypedRefCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_2_1_0()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypedRefCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1" |
| |
| // $ANTLR start synpred55_InternalEssentialOCL |
| public final void synpred55_InternalEssentialOCL_fragment() throws RecognitionException { |
| // InternalEssentialOCL.g:3057:6: ( ( ruleTypeLiteralCS ) ) |
| // InternalEssentialOCL.g:3057:6: ( ruleTypeLiteralCS ) |
| { |
| // InternalEssentialOCL.g:3057:6: ( ruleTypeLiteralCS ) |
| // InternalEssentialOCL.g:3058:1: ruleTypeLiteralCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_1()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeLiteralCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred55_InternalEssentialOCL |
| |
| // $ANTLR start synpred56_InternalEssentialOCL |
| public final void synpred56_InternalEssentialOCL_fragment() throws RecognitionException { |
| // InternalEssentialOCL.g:3079:1: ( ( ( rule__ExpCS__Group_0__0 ) ) ) |
| // InternalEssentialOCL.g:3079:1: ( ( rule__ExpCS__Group_0__0 ) ) |
| { |
| // InternalEssentialOCL.g:3079:1: ( ( rule__ExpCS__Group_0__0 ) ) |
| // InternalEssentialOCL.g:3080:1: ( rule__ExpCS__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getExpCSAccess().getGroup_0()); |
| } |
| // InternalEssentialOCL.g:3081:1: ( rule__ExpCS__Group_0__0 ) |
| // InternalEssentialOCL.g:3081:2: rule__ExpCS__Group_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__ExpCS__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred56_InternalEssentialOCL |
| |
| // $ANTLR start synpred63_InternalEssentialOCL |
| public final void synpred63_InternalEssentialOCL_fragment() throws RecognitionException { |
| // InternalEssentialOCL.g:3169:6: ( ( ruleTupleLiteralExpCS ) ) |
| // InternalEssentialOCL.g:3169:6: ( ruleTupleLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:3169:6: ( ruleTupleLiteralExpCS ) |
| // InternalEssentialOCL.g:3170:1: ruleTupleLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTupleLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred63_InternalEssentialOCL |
| |
| // $ANTLR start synpred64_InternalEssentialOCL |
| public final void synpred64_InternalEssentialOCL_fragment() throws RecognitionException { |
| // InternalEssentialOCL.g:3175:6: ( ( ruleMapLiteralExpCS ) ) |
| // InternalEssentialOCL.g:3175:6: ( ruleMapLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:3175:6: ( ruleMapLiteralExpCS ) |
| // InternalEssentialOCL.g:3176:1: ruleMapLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleMapLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred64_InternalEssentialOCL |
| |
| // $ANTLR start synpred65_InternalEssentialOCL |
| public final void synpred65_InternalEssentialOCL_fragment() throws RecognitionException { |
| // InternalEssentialOCL.g:3181:6: ( ( ruleCollectionLiteralExpCS ) ) |
| // InternalEssentialOCL.g:3181:6: ( ruleCollectionLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:3181:6: ( ruleCollectionLiteralExpCS ) |
| // InternalEssentialOCL.g:3182:1: ruleCollectionLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleCollectionLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred65_InternalEssentialOCL |
| |
| // $ANTLR start synpred67_InternalEssentialOCL |
| public final void synpred67_InternalEssentialOCL_fragment() throws RecognitionException { |
| // InternalEssentialOCL.g:3193:6: ( ( ruleTypeLiteralExpCS ) ) |
| // InternalEssentialOCL.g:3193:6: ( ruleTypeLiteralExpCS ) |
| { |
| // InternalEssentialOCL.g:3193:6: ( ruleTypeLiteralExpCS ) |
| // InternalEssentialOCL.g:3194:1: ruleTypeLiteralExpCS |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8()); |
| } |
| pushFollow(FollowSets000.FOLLOW_2); |
| ruleTypeLiteralExpCS(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred67_InternalEssentialOCL |
| |
| // $ANTLR start synpred71_InternalEssentialOCL |
| public final void synpred71_InternalEssentialOCL_fragment() throws RecognitionException { |
| // InternalEssentialOCL.g:3265:1: ( ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) ) |
| // InternalEssentialOCL.g:3265:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) |
| { |
| // InternalEssentialOCL.g:3265:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) |
| // InternalEssentialOCL.g:3266:1: ( rule__NavigatingArgCS__Group_0_1_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0()); |
| } |
| // InternalEssentialOCL.g:3267:1: ( rule__NavigatingArgCS__Group_0_1_0__0 ) |
| // InternalEssentialOCL.g:3267:2: rule__NavigatingArgCS__Group_0_1_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred71_InternalEssentialOCL |
| |
| // $ANTLR start synpred72_InternalEssentialOCL |
| public final void synpred72_InternalEssentialOCL_fragment() throws RecognitionException { |
| // InternalEssentialOCL.g:3271:6: ( ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) ) |
| // InternalEssentialOCL.g:3271:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) |
| { |
| // InternalEssentialOCL.g:3271:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) |
| // InternalEssentialOCL.g:3272:1: ( rule__NavigatingArgCS__Group_0_1_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1()); |
| } |
| // InternalEssentialOCL.g:3273:1: ( rule__NavigatingArgCS__Group_0_1_1__0 ) |
| // InternalEssentialOCL.g:3273:2: rule__NavigatingArgCS__Group_0_1_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingArgCS__Group_0_1_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred72_InternalEssentialOCL |
| |
| // $ANTLR start synpred76_InternalEssentialOCL |
| public final void synpred76_InternalEssentialOCL_fragment() throws RecognitionException { |
| // InternalEssentialOCL.g:3371:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) ) |
| // InternalEssentialOCL.g:3371:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) |
| { |
| // InternalEssentialOCL.g:3371:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) |
| // InternalEssentialOCL.g:3372:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0()); |
| } |
| // InternalEssentialOCL.g:3373:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 ) |
| // InternalEssentialOCL.g:3373:2: rule__NavigatingCommaArgCS__Group_2_0__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred76_InternalEssentialOCL |
| |
| // $ANTLR start synpred77_InternalEssentialOCL |
| public final void synpred77_InternalEssentialOCL_fragment() throws RecognitionException { |
| // InternalEssentialOCL.g:3377:6: ( ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) ) |
| // InternalEssentialOCL.g:3377:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) |
| { |
| // InternalEssentialOCL.g:3377:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) |
| // InternalEssentialOCL.g:3378:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1()); |
| } |
| // InternalEssentialOCL.g:3379:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 ) |
| // InternalEssentialOCL.g:3379:2: rule__NavigatingCommaArgCS__Group_2_1__0 |
| { |
| pushFollow(FollowSets000.FOLLOW_2); |
| rule__NavigatingCommaArgCS__Group_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| } |
| // $ANTLR end synpred77_InternalEssentialOCL |
| |
| // Delegated rules |
| |
| public final boolean synpred64_InternalEssentialOCL() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred64_InternalEssentialOCL_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 synpred67_InternalEssentialOCL() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred67_InternalEssentialOCL_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 synpred56_InternalEssentialOCL() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred56_InternalEssentialOCL_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 synpred76_InternalEssentialOCL() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred76_InternalEssentialOCL_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 synpred72_InternalEssentialOCL() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred72_InternalEssentialOCL_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 synpred63_InternalEssentialOCL() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred63_InternalEssentialOCL_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 synpred65_InternalEssentialOCL() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred65_InternalEssentialOCL_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 synpred77_InternalEssentialOCL() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred77_InternalEssentialOCL_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 synpred71_InternalEssentialOCL() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred71_InternalEssentialOCL_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 synpred55_InternalEssentialOCL() { |
| state.backtracking++; |
| int start = input.mark(); |
| try { |
| synpred55_InternalEssentialOCL_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 DFA17 dfa17 = new DFA17(this); |
| protected DFA18 dfa18 = new DFA18(this); |
| protected DFA21 dfa21 = new DFA21(this); |
| static final String dfa_1s = "\23\uffff"; |
| static final String dfa_2s = "\1\6\12\uffff\5\0\3\uffff"; |
| static final String dfa_3s = "\1\66\12\uffff\5\0\3\uffff"; |
| static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\2\16\uffff\1\3"; |
| static final String dfa_5s = "\13\uffff\1\0\1\1\1\2\1\3\1\4\3\uffff}>"; |
| static final String[] dfa_6s = { |
| "\2\1\40\uffff\12\3\1\13\1\14\1\15\1\16\1\17", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); |
| static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); |
| static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); |
| static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); |
| static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); |
| static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); |
| |
| class DFA17 extends DFA { |
| |
| public DFA17(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 17; |
| this.eot = dfa_1; |
| this.eof = dfa_1; |
| this.min = dfa_2; |
| this.max = dfa_3; |
| this.accept = dfa_4; |
| this.special = dfa_5; |
| this.transition = dfa_6; |
| } |
| public String getDescription() { |
| return "3046:1: rule__TypeExpWithoutMultiplicityCS__Alternatives : ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) );"; |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA17_11 = input.LA(1); |
| |
| |
| int index17_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred55_InternalEssentialOCL()) ) {s = 3;} |
| |
| else if ( (true) ) {s = 18;} |
| |
| |
| input.seek(index17_11); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA17_12 = input.LA(1); |
| |
| |
| int index17_12 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred55_InternalEssentialOCL()) ) {s = 3;} |
| |
| else if ( (true) ) {s = 18;} |
| |
| |
| input.seek(index17_12); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA17_13 = input.LA(1); |
| |
| |
| int index17_13 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred55_InternalEssentialOCL()) ) {s = 3;} |
| |
| else if ( (true) ) {s = 18;} |
| |
| |
| input.seek(index17_13); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA17_14 = input.LA(1); |
| |
| |
| int index17_14 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred55_InternalEssentialOCL()) ) {s = 3;} |
| |
| else if ( (true) ) {s = 18;} |
| |
| |
| input.seek(index17_14); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA17_15 = input.LA(1); |
| |
| |
| int index17_15 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred55_InternalEssentialOCL()) ) {s = 3;} |
| |
| else if ( (true) ) {s = 18;} |
| |
| |
| input.seek(index17_15); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 17, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String dfa_7s = "\41\uffff"; |
| static final String dfa_8s = "\1\4\3\0\35\uffff"; |
| static final String dfa_9s = "\1\125\3\0\35\uffff"; |
| static final String dfa_10s = "\4\uffff\1\1\33\uffff\1\2"; |
| static final String dfa_11s = "\1\uffff\1\0\1\1\1\2\35\uffff}>"; |
| static final String[] dfa_12s = { |
| "\4\4\10\uffff\1\1\1\2\1\3\1\4\24\uffff\17\4\4\uffff\1\4\7\uffff\3\4\4\uffff\1\4\4\uffff\1\40\1\4\3\uffff\2\4", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); |
| 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 DFA18 extends DFA { |
| |
| public DFA18(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 18; |
| this.eot = dfa_7; |
| this.eof = dfa_7; |
| this.min = dfa_8; |
| this.max = dfa_9; |
| this.accept = dfa_10; |
| this.special = dfa_11; |
| this.transition = dfa_12; |
| } |
| public String getDescription() { |
| return "3074:1: rule__ExpCS__Alternatives : ( ( ( rule__ExpCS__Group_0__0 ) ) | ( rulePrefixedLetExpCS ) );"; |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA18_1 = input.LA(1); |
| |
| |
| int index18_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred56_InternalEssentialOCL()) ) {s = 4;} |
| |
| else if ( (true) ) {s = 32;} |
| |
| |
| input.seek(index18_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA18_2 = input.LA(1); |
| |
| |
| int index18_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred56_InternalEssentialOCL()) ) {s = 4;} |
| |
| else if ( (true) ) {s = 32;} |
| |
| |
| input.seek(index18_2); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA18_3 = input.LA(1); |
| |
| |
| int index18_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred56_InternalEssentialOCL()) ) {s = 4;} |
| |
| else if ( (true) ) {s = 32;} |
| |
| |
| input.seek(index18_3); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 18, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String dfa_13s = "\40\uffff"; |
| static final String dfa_14s = "\1\4\12\uffff\7\0\16\uffff"; |
| static final String dfa_15s = "\1\125\12\uffff\7\0\16\uffff"; |
| static final String dfa_16s = "\1\uffff\1\1\1\2\1\3\1\4\15\uffff\1\10\1\11\7\uffff\1\12\1\uffff\1\5\1\6\1\7"; |
| static final String dfa_17s = "\13\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\16\uffff}>"; |
| static final String[] dfa_18s = { |
| "\2\4\2\33\13\uffff\1\4\24\uffff\1\14\1\13\10\23\1\15\1\16\1\17\1\20\1\21\4\uffff\1\1\7\uffff\1\22\2\4\4\uffff\1\2\5\uffff\1\3\3\uffff\2\4", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s); |
| static final char[] dfa_14 = DFA.unpackEncodedStringToUnsignedChars(dfa_14s); |
| static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s); |
| static final short[] dfa_16 = DFA.unpackEncodedString(dfa_16s); |
| static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); |
| static final short[][] dfa_18 = unpackEncodedStringArray(dfa_18s); |
| |
| class DFA21 extends DFA { |
| |
| public DFA21(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 21; |
| this.eot = dfa_13; |
| this.eof = dfa_13; |
| this.min = dfa_14; |
| this.max = dfa_15; |
| this.accept = dfa_16; |
| this.special = dfa_17; |
| this.transition = dfa_18; |
| } |
| public String getDescription() { |
| return "3140:1: rule__PrimaryExpCS__Alternatives : ( ( ruleNestedExpCS ) | ( ruleIfExpCS ) | ( ruleSelfExpCS ) | ( rulePrimitiveLiteralExpCS ) | ( ruleTupleLiteralExpCS ) | ( ruleMapLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) | ( ruleLambdaLiteralExpCS ) | ( ruleTypeLiteralExpCS ) | ( ruleNameExpCS ) );"; |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA21_11 = input.LA(1); |
| |
| |
| int index21_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred63_InternalEssentialOCL()) ) {s = 29;} |
| |
| else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;} |
| |
| |
| input.seek(index21_11); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA21_12 = input.LA(1); |
| |
| |
| int index21_12 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred64_InternalEssentialOCL()) ) {s = 30;} |
| |
| else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;} |
| |
| |
| input.seek(index21_12); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA21_13 = input.LA(1); |
| |
| |
| int index21_13 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred65_InternalEssentialOCL()) ) {s = 31;} |
| |
| else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;} |
| |
| |
| input.seek(index21_13); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA21_14 = input.LA(1); |
| |
| |
| int index21_14 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred65_InternalEssentialOCL()) ) {s = 31;} |
| |
| else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;} |
| |
| |
| input.seek(index21_14); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA21_15 = input.LA(1); |
| |
| |
| int index21_15 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred65_InternalEssentialOCL()) ) {s = 31;} |
| |
| else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;} |
| |
| |
| input.seek(index21_15); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA21_16 = input.LA(1); |
| |
| |
| int index21_16 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred65_InternalEssentialOCL()) ) {s = 31;} |
| |
| else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;} |
| |
| |
| input.seek(index21_16); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA21_17 = input.LA(1); |
| |
| |
| int index21_17 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred65_InternalEssentialOCL()) ) {s = 31;} |
| |
| else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;} |
| |
| |
| input.seek(index21_17); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 21, _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[]{0x0000000000000022L}); |
| public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000020L}); |
| public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0800000000000000L}); |
| public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x007FFF00000000C0L}); |
| public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x1000000000000000L,0x0000000000000080L}); |
| public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x2000000000000000L}); |
| public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x1000000000000000L}); |
| public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x10000000000000C0L}); |
| public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x2000000000000002L}); |
| public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x00000000000000C0L}); |
| public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x4000000000000000L}); |
| public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x8000000000000000L}); |
| public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x487FFF00000F00F0L,0x0000000000318439L}); |
| public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x487FFF00000F00F0L,0x0000000000318438L}); |
| public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x087FFF00000F00F0L,0x0000000000318438L}); |
| public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000004L}); |
| public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000004000000L}); |
| public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x087FFF00000F00F0L,0x0000000000318439L}); |
| public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0180000000000000L}); |
| public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x4000000004000000L}); |
| public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000080000L}); |
| public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); |
| public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000080030L,0x0000000000300030L}); |
| public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L}); |
| public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x000000FFFFF90000L}); |
| public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000070000L}); |
| public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x087FFF00000F00F0L,0x0000000000310438L}); |
| public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x8800000000000000L,0x0000000000400080L}); |
| public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L}); |
| public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); |
| public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x00000000000000E0L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x00000000000000E0L}); |
| public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x587FFF00000F00F0L,0x0000000000318438L}); |
| public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x2000000000000000L,0x0000000001800000L}); |
| public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x2000000000000002L,0x0000000001800000L}); |
| public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000100L}); |
| public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x4180000000000000L,0x0000000000000200L}); |
| public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0180000004000000L}); |
| public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L}); |
| public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000000L,0x0000000000005000L}); |
| public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); |
| public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000200L}); |
| public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x4800000004000000L}); |
| public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
| public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000080010L}); |
| public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0400000000280010L}); |
| public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0200000000000000L,0x0000000002000100L}); |
| public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); |
| public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000002L,0x0000000000020000L}); |
| public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000080L}); |
| public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x04000000000000C0L}); |
| public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080000L}); |
| } |
| |
| |
| } |
