| /** |
| * |
| * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation |
| */ |
| |
| package org.eclipse.osbp.xtext.gridsource.ide.contentassist.antlr.internal; |
| |
| import java.io.InputStream; |
| import org.eclipse.xtext.*; |
| import org.eclipse.xtext.parser.*; |
| import org.eclipse.xtext.parser.impl.*; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.xtext.parser.antlr.XtextTokenStream; |
| import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; |
| import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; |
| import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA; |
| import org.eclipse.osbp.xtext.gridsource.services.GridSourceGrammarAccess; |
| |
| |
| |
| import org.antlr.runtime.*; |
| import java.util.Stack; |
| import java.util.List; |
| import java.util.ArrayList; |
| import java.util.Map; |
| import java.util.HashMap; |
| @SuppressWarnings("all") |
| public class InternalGridSourceParser extends AbstractInternalContentAssistParser { |
| public static final String[] tokenNames = new String[] { |
| "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_ID", "RULE_INT", "RULE_STRING", "RULE_THEME_RESOURCE", "RULE_EVENT_TOPIC", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'+'", "'-'", "'equal'", "'greater equal'", "'greater than'", "'lower equal'", "'lower than'", "'not equal'", "'gridsource'", "'for'", "'{'", "'inputs'", "'}'", "'inputType'", "'filters'", "'&&'", "'root:'", "'='", "'input:'", "'prop'", "'style'", "'.'", "'buttonStyle'", "'eventTopic'", "'htmlStyle'", "'boolStyle'", "'dateStyle'", "'format'", "'numberStyle'", "'progressbarStyle'", "'max'", "'indicatorStyle'", "'greenFrom'", "'redUntil'", "'quantityStyle'", "'value'", "'uom'", "'('", "')'", "'priceStyle'", "'currency'", "'textStyle'", "'imageStyle'", "'number'", "'then'", "'string'", "'['", "']'", "'=>'", "','", "'<'", "'>'", "'?'", "'extends'", "'&'", "'super'", "'*'", "'import'", "';'", "'static'", "'extension'" |
| }; |
| public static final int T__50=50; |
| public static final int T__19=19; |
| public static final int T__15=15; |
| public static final int T__59=59; |
| public static final int T__16=16; |
| public static final int T__17=17; |
| public static final int T__18=18; |
| public static final int T__55=55; |
| public static final int T__56=56; |
| public static final int T__13=13; |
| public static final int T__57=57; |
| public static final int T__14=14; |
| public static final int T__58=58; |
| public static final int T__51=51; |
| public static final int T__52=52; |
| public static final int T__53=53; |
| public static final int T__54=54; |
| public static final int T__60=60; |
| public static final int T__61=61; |
| public static final int RULE_ID=4; |
| public static final int T__26=26; |
| public static final int T__27=27; |
| public static final int RULE_EVENT_TOPIC=8; |
| public static final int T__28=28; |
| public static final int RULE_INT=5; |
| 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=9; |
| public static final int T__23=23; |
| public static final int T__67=67; |
| public static final int T__24=24; |
| public static final int T__68=68; |
| public static final int T__25=25; |
| public static final int T__69=69; |
| public static final int T__62=62; |
| public static final int T__63=63; |
| public static final int T__20=20; |
| public static final int T__64=64; |
| public static final int T__21=21; |
| public static final int T__65=65; |
| public static final int T__70=70; |
| public static final int T__71=71; |
| public static final int T__72=72; |
| public static final int RULE_STRING=6; |
| public static final int RULE_SL_COMMENT=10; |
| public static final int T__37=37; |
| public static final int T__38=38; |
| public static final int T__39=39; |
| public static final int T__33=33; |
| public static final int T__34=34; |
| public static final int T__35=35; |
| public static final int T__36=36; |
| public static final int T__73=73; |
| public static final int EOF=-1; |
| public static final int T__30=30; |
| public static final int T__31=31; |
| public static final int T__32=32; |
| public static final int RULE_WS=11; |
| public static final int RULE_ANY_OTHER=12; |
| public static final int T__48=48; |
| public static final int T__49=49; |
| public static final int T__44=44; |
| public static final int T__45=45; |
| public static final int T__46=46; |
| public static final int T__47=47; |
| public static final int RULE_THEME_RESOURCE=7; |
| public static final int T__40=40; |
| public static final int T__41=41; |
| public static final int T__42=42; |
| public static final int T__43=43; |
| |
| // delegates |
| // delegators |
| |
| |
| public InternalGridSourceParser(TokenStream input) { |
| this(input, new RecognizerSharedState()); |
| } |
| public InternalGridSourceParser(TokenStream input, RecognizerSharedState state) { |
| super(input, state); |
| |
| } |
| |
| |
| public String[] getTokenNames() { return InternalGridSourceParser.tokenNames; } |
| public String getGrammarFileName() { return "InternalGridSource.g"; } |
| |
| |
| private GridSourceGrammarAccess grammarAccess; |
| |
| public void setGrammarAccess(GridSourceGrammarAccess grammarAccess) { |
| this.grammarAccess = grammarAccess; |
| } |
| |
| @Override |
| protected Grammar getGrammar() { |
| return grammarAccess.getGrammar(); |
| } |
| |
| @Override |
| protected String getValueForTokenName(String tokenName) { |
| return tokenName; |
| } |
| |
| |
| |
| // $ANTLR start "entryRuleSource" |
| // InternalGridSource.g:54:1: entryRuleSource : ruleSource EOF ; |
| public final void entryRuleSource() throws RecognitionException { |
| try { |
| // InternalGridSource.g:55:1: ( ruleSource EOF ) |
| // InternalGridSource.g:56:1: ruleSource EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleSource(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleSource" |
| |
| |
| // $ANTLR start "ruleSource" |
| // InternalGridSource.g:63:1: ruleSource : ( ( rule__Source__Group__0 ) ) ; |
| public final void ruleSource() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:67:2: ( ( ( rule__Source__Group__0 ) ) ) |
| // InternalGridSource.g:68:2: ( ( rule__Source__Group__0 ) ) |
| { |
| // InternalGridSource.g:68:2: ( ( rule__Source__Group__0 ) ) |
| // InternalGridSource.g:69:3: ( rule__Source__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getGroup()); |
| } |
| // InternalGridSource.g:70:3: ( rule__Source__Group__0 ) |
| // InternalGridSource.g:70:4: rule__Source__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleSource" |
| |
| |
| // $ANTLR start "entryRuleInput" |
| // InternalGridSource.g:79:1: entryRuleInput : ruleInput EOF ; |
| public final void entryRuleInput() throws RecognitionException { |
| try { |
| // InternalGridSource.g:80:1: ( ruleInput EOF ) |
| // InternalGridSource.g:81:1: ruleInput EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleInput(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleInput" |
| |
| |
| // $ANTLR start "ruleInput" |
| // InternalGridSource.g:88:1: ruleInput : ( ( rule__Input__Group__0 ) ) ; |
| public final void ruleInput() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:92:2: ( ( ( rule__Input__Group__0 ) ) ) |
| // InternalGridSource.g:93:2: ( ( rule__Input__Group__0 ) ) |
| { |
| // InternalGridSource.g:93:2: ( ( rule__Input__Group__0 ) ) |
| // InternalGridSource.g:94:3: ( rule__Input__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputAccess().getGroup()); |
| } |
| // InternalGridSource.g:95:3: ( rule__Input__Group__0 ) |
| // InternalGridSource.g:95:4: rule__Input__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Input__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleInput" |
| |
| |
| // $ANTLR start "entryRuleEQFilter" |
| // InternalGridSource.g:104:1: entryRuleEQFilter : ruleEQFilter EOF ; |
| public final void entryRuleEQFilter() throws RecognitionException { |
| try { |
| // InternalGridSource.g:105:1: ( ruleEQFilter EOF ) |
| // InternalGridSource.g:106:1: ruleEQFilter EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEQFilterRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleEQFilter(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEQFilterRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEQFilter" |
| |
| |
| // $ANTLR start "ruleEQFilter" |
| // InternalGridSource.g:113:1: ruleEQFilter : ( ( rule__EQFilter__Group__0 ) ) ; |
| public final void ruleEQFilter() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:117:2: ( ( ( rule__EQFilter__Group__0 ) ) ) |
| // InternalGridSource.g:118:2: ( ( rule__EQFilter__Group__0 ) ) |
| { |
| // InternalGridSource.g:118:2: ( ( rule__EQFilter__Group__0 ) ) |
| // InternalGridSource.g:119:3: ( rule__EQFilter__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEQFilterAccess().getGroup()); |
| } |
| // InternalGridSource.g:120:3: ( rule__EQFilter__Group__0 ) |
| // InternalGridSource.g:120:4: rule__EQFilter__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__EQFilter__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEQFilterAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEQFilter" |
| |
| |
| // $ANTLR start "entryRuleProperty" |
| // InternalGridSource.g:129:1: entryRuleProperty : ruleProperty EOF ; |
| public final void entryRuleProperty() throws RecognitionException { |
| try { |
| // InternalGridSource.g:130:1: ( ruleProperty EOF ) |
| // InternalGridSource.g:131:1: ruleProperty EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleProperty(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleProperty" |
| |
| |
| // $ANTLR start "ruleProperty" |
| // InternalGridSource.g:138:1: ruleProperty : ( ( rule__Property__Group__0 ) ) ; |
| public final void ruleProperty() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:142:2: ( ( ( rule__Property__Group__0 ) ) ) |
| // InternalGridSource.g:143:2: ( ( rule__Property__Group__0 ) ) |
| { |
| // InternalGridSource.g:143:2: ( ( rule__Property__Group__0 ) ) |
| // InternalGridSource.g:144:3: ( rule__Property__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyAccess().getGroup()); |
| } |
| // InternalGridSource.g:145:3: ( rule__Property__Group__0 ) |
| // InternalGridSource.g:145:4: rule__Property__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Property__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleProperty" |
| |
| |
| // $ANTLR start "entryRuleNestedField" |
| // InternalGridSource.g:154:1: entryRuleNestedField : ruleNestedField EOF ; |
| public final void entryRuleNestedField() throws RecognitionException { |
| try { |
| // InternalGridSource.g:155:1: ( ruleNestedField EOF ) |
| // InternalGridSource.g:156:1: ruleNestedField EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedFieldRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleNestedField(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedFieldRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNestedField" |
| |
| |
| // $ANTLR start "ruleNestedField" |
| // InternalGridSource.g:163:1: ruleNestedField : ( ( rule__NestedField__Group__0 ) ) ; |
| public final void ruleNestedField() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:167:2: ( ( ( rule__NestedField__Group__0 ) ) ) |
| // InternalGridSource.g:168:2: ( ( rule__NestedField__Group__0 ) ) |
| { |
| // InternalGridSource.g:168:2: ( ( rule__NestedField__Group__0 ) ) |
| // InternalGridSource.g:169:3: ( rule__NestedField__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedFieldAccess().getGroup()); |
| } |
| // InternalGridSource.g:170:3: ( rule__NestedField__Group__0 ) |
| // InternalGridSource.g:170:4: rule__NestedField__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__NestedField__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedFieldAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNestedField" |
| |
| |
| // $ANTLR start "entryRuleNestedPath" |
| // InternalGridSource.g:179:1: entryRuleNestedPath : ruleNestedPath EOF ; |
| public final void entryRuleNestedPath() throws RecognitionException { |
| try { |
| // InternalGridSource.g:180:1: ( ruleNestedPath EOF ) |
| // InternalGridSource.g:181:1: ruleNestedPath EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedPathRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleNestedPath(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedPathRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNestedPath" |
| |
| |
| // $ANTLR start "ruleNestedPath" |
| // InternalGridSource.g:188:1: ruleNestedPath : ( ( rule__NestedPath__Group__0 ) ) ; |
| public final void ruleNestedPath() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:192:2: ( ( ( rule__NestedPath__Group__0 ) ) ) |
| // InternalGridSource.g:193:2: ( ( rule__NestedPath__Group__0 ) ) |
| { |
| // InternalGridSource.g:193:2: ( ( rule__NestedPath__Group__0 ) ) |
| // InternalGridSource.g:194:3: ( rule__NestedPath__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedPathAccess().getGroup()); |
| } |
| // InternalGridSource.g:195:3: ( rule__NestedPath__Group__0 ) |
| // InternalGridSource.g:195:4: rule__NestedPath__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__NestedPath__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedPathAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNestedPath" |
| |
| |
| // $ANTLR start "entryRulePropertyStyle" |
| // InternalGridSource.g:204:1: entryRulePropertyStyle : rulePropertyStyle EOF ; |
| public final void entryRulePropertyStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:205:1: ( rulePropertyStyle EOF ) |
| // InternalGridSource.g:206:1: rulePropertyStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| rulePropertyStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePropertyStyle" |
| |
| |
| // $ANTLR start "rulePropertyStyle" |
| // InternalGridSource.g:213:1: rulePropertyStyle : ( ( rule__PropertyStyle__Alternatives ) ) ; |
| public final void rulePropertyStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:217:2: ( ( ( rule__PropertyStyle__Alternatives ) ) ) |
| // InternalGridSource.g:218:2: ( ( rule__PropertyStyle__Alternatives ) ) |
| { |
| // InternalGridSource.g:218:2: ( ( rule__PropertyStyle__Alternatives ) ) |
| // InternalGridSource.g:219:3: ( rule__PropertyStyle__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getAlternatives()); |
| } |
| // InternalGridSource.g:220:3: ( rule__PropertyStyle__Alternatives ) |
| // InternalGridSource.g:220:4: rule__PropertyStyle__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyStyle__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePropertyStyle" |
| |
| |
| // $ANTLR start "entryRulePropertyButtonStyle" |
| // InternalGridSource.g:229:1: entryRulePropertyButtonStyle : rulePropertyButtonStyle EOF ; |
| public final void entryRulePropertyButtonStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:230:1: ( rulePropertyButtonStyle EOF ) |
| // InternalGridSource.g:231:1: rulePropertyButtonStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyButtonStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| rulePropertyButtonStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyButtonStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePropertyButtonStyle" |
| |
| |
| // $ANTLR start "rulePropertyButtonStyle" |
| // InternalGridSource.g:238:1: rulePropertyButtonStyle : ( ( rule__PropertyButtonStyle__Group__0 ) ) ; |
| public final void rulePropertyButtonStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:242:2: ( ( ( rule__PropertyButtonStyle__Group__0 ) ) ) |
| // InternalGridSource.g:243:2: ( ( rule__PropertyButtonStyle__Group__0 ) ) |
| { |
| // InternalGridSource.g:243:2: ( ( rule__PropertyButtonStyle__Group__0 ) ) |
| // InternalGridSource.g:244:3: ( rule__PropertyButtonStyle__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyButtonStyleAccess().getGroup()); |
| } |
| // InternalGridSource.g:245:3: ( rule__PropertyButtonStyle__Group__0 ) |
| // InternalGridSource.g:245:4: rule__PropertyButtonStyle__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyButtonStyle__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyButtonStyleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePropertyButtonStyle" |
| |
| |
| // $ANTLR start "entryRulePropertyHtmlStyle" |
| // InternalGridSource.g:254:1: entryRulePropertyHtmlStyle : rulePropertyHtmlStyle EOF ; |
| public final void entryRulePropertyHtmlStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:255:1: ( rulePropertyHtmlStyle EOF ) |
| // InternalGridSource.g:256:1: rulePropertyHtmlStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyHtmlStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| rulePropertyHtmlStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyHtmlStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePropertyHtmlStyle" |
| |
| |
| // $ANTLR start "rulePropertyHtmlStyle" |
| // InternalGridSource.g:263:1: rulePropertyHtmlStyle : ( ( rule__PropertyHtmlStyle__Group__0 ) ) ; |
| public final void rulePropertyHtmlStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:267:2: ( ( ( rule__PropertyHtmlStyle__Group__0 ) ) ) |
| // InternalGridSource.g:268:2: ( ( rule__PropertyHtmlStyle__Group__0 ) ) |
| { |
| // InternalGridSource.g:268:2: ( ( rule__PropertyHtmlStyle__Group__0 ) ) |
| // InternalGridSource.g:269:3: ( rule__PropertyHtmlStyle__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyHtmlStyleAccess().getGroup()); |
| } |
| // InternalGridSource.g:270:3: ( rule__PropertyHtmlStyle__Group__0 ) |
| // InternalGridSource.g:270:4: rule__PropertyHtmlStyle__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyHtmlStyle__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyHtmlStyleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePropertyHtmlStyle" |
| |
| |
| // $ANTLR start "entryRulePropertyBooleanStyle" |
| // InternalGridSource.g:279:1: entryRulePropertyBooleanStyle : rulePropertyBooleanStyle EOF ; |
| public final void entryRulePropertyBooleanStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:280:1: ( rulePropertyBooleanStyle EOF ) |
| // InternalGridSource.g:281:1: rulePropertyBooleanStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyBooleanStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| rulePropertyBooleanStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyBooleanStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePropertyBooleanStyle" |
| |
| |
| // $ANTLR start "rulePropertyBooleanStyle" |
| // InternalGridSource.g:288:1: rulePropertyBooleanStyle : ( ( rule__PropertyBooleanStyle__Group__0 ) ) ; |
| public final void rulePropertyBooleanStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:292:2: ( ( ( rule__PropertyBooleanStyle__Group__0 ) ) ) |
| // InternalGridSource.g:293:2: ( ( rule__PropertyBooleanStyle__Group__0 ) ) |
| { |
| // InternalGridSource.g:293:2: ( ( rule__PropertyBooleanStyle__Group__0 ) ) |
| // InternalGridSource.g:294:3: ( rule__PropertyBooleanStyle__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyBooleanStyleAccess().getGroup()); |
| } |
| // InternalGridSource.g:295:3: ( rule__PropertyBooleanStyle__Group__0 ) |
| // InternalGridSource.g:295:4: rule__PropertyBooleanStyle__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyBooleanStyle__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyBooleanStyleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePropertyBooleanStyle" |
| |
| |
| // $ANTLR start "entryRulePropertyDateStyle" |
| // InternalGridSource.g:304:1: entryRulePropertyDateStyle : rulePropertyDateStyle EOF ; |
| public final void entryRulePropertyDateStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:305:1: ( rulePropertyDateStyle EOF ) |
| // InternalGridSource.g:306:1: rulePropertyDateStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyDateStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| rulePropertyDateStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyDateStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePropertyDateStyle" |
| |
| |
| // $ANTLR start "rulePropertyDateStyle" |
| // InternalGridSource.g:313:1: rulePropertyDateStyle : ( ( rule__PropertyDateStyle__Group__0 ) ) ; |
| public final void rulePropertyDateStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:317:2: ( ( ( rule__PropertyDateStyle__Group__0 ) ) ) |
| // InternalGridSource.g:318:2: ( ( rule__PropertyDateStyle__Group__0 ) ) |
| { |
| // InternalGridSource.g:318:2: ( ( rule__PropertyDateStyle__Group__0 ) ) |
| // InternalGridSource.g:319:3: ( rule__PropertyDateStyle__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyDateStyleAccess().getGroup()); |
| } |
| // InternalGridSource.g:320:3: ( rule__PropertyDateStyle__Group__0 ) |
| // InternalGridSource.g:320:4: rule__PropertyDateStyle__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyDateStyle__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyDateStyleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePropertyDateStyle" |
| |
| |
| // $ANTLR start "entryRulePropertyNumberStyle" |
| // InternalGridSource.g:329:1: entryRulePropertyNumberStyle : rulePropertyNumberStyle EOF ; |
| public final void entryRulePropertyNumberStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:330:1: ( rulePropertyNumberStyle EOF ) |
| // InternalGridSource.g:331:1: rulePropertyNumberStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyNumberStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| rulePropertyNumberStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyNumberStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePropertyNumberStyle" |
| |
| |
| // $ANTLR start "rulePropertyNumberStyle" |
| // InternalGridSource.g:338:1: rulePropertyNumberStyle : ( ( rule__PropertyNumberStyle__Group__0 ) ) ; |
| public final void rulePropertyNumberStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:342:2: ( ( ( rule__PropertyNumberStyle__Group__0 ) ) ) |
| // InternalGridSource.g:343:2: ( ( rule__PropertyNumberStyle__Group__0 ) ) |
| { |
| // InternalGridSource.g:343:2: ( ( rule__PropertyNumberStyle__Group__0 ) ) |
| // InternalGridSource.g:344:3: ( rule__PropertyNumberStyle__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyNumberStyleAccess().getGroup()); |
| } |
| // InternalGridSource.g:345:3: ( rule__PropertyNumberStyle__Group__0 ) |
| // InternalGridSource.g:345:4: rule__PropertyNumberStyle__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyNumberStyle__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyNumberStyleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePropertyNumberStyle" |
| |
| |
| // $ANTLR start "entryRulePropertyProgressbarStyle" |
| // InternalGridSource.g:354:1: entryRulePropertyProgressbarStyle : rulePropertyProgressbarStyle EOF ; |
| public final void entryRulePropertyProgressbarStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:355:1: ( rulePropertyProgressbarStyle EOF ) |
| // InternalGridSource.g:356:1: rulePropertyProgressbarStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyProgressbarStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| rulePropertyProgressbarStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyProgressbarStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePropertyProgressbarStyle" |
| |
| |
| // $ANTLR start "rulePropertyProgressbarStyle" |
| // InternalGridSource.g:363:1: rulePropertyProgressbarStyle : ( ( rule__PropertyProgressbarStyle__Group__0 ) ) ; |
| public final void rulePropertyProgressbarStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:367:2: ( ( ( rule__PropertyProgressbarStyle__Group__0 ) ) ) |
| // InternalGridSource.g:368:2: ( ( rule__PropertyProgressbarStyle__Group__0 ) ) |
| { |
| // InternalGridSource.g:368:2: ( ( rule__PropertyProgressbarStyle__Group__0 ) ) |
| // InternalGridSource.g:369:3: ( rule__PropertyProgressbarStyle__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyProgressbarStyleAccess().getGroup()); |
| } |
| // InternalGridSource.g:370:3: ( rule__PropertyProgressbarStyle__Group__0 ) |
| // InternalGridSource.g:370:4: rule__PropertyProgressbarStyle__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyProgressbarStyle__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyProgressbarStyleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePropertyProgressbarStyle" |
| |
| |
| // $ANTLR start "entryRuleGridPropIndicatorStyle" |
| // InternalGridSource.g:379:1: entryRuleGridPropIndicatorStyle : ruleGridPropIndicatorStyle EOF ; |
| public final void entryRuleGridPropIndicatorStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:380:1: ( ruleGridPropIndicatorStyle EOF ) |
| // InternalGridSource.g:381:1: ruleGridPropIndicatorStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getGridPropIndicatorStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleGridPropIndicatorStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getGridPropIndicatorStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleGridPropIndicatorStyle" |
| |
| |
| // $ANTLR start "ruleGridPropIndicatorStyle" |
| // InternalGridSource.g:388:1: ruleGridPropIndicatorStyle : ( ( rule__GridPropIndicatorStyle__Group__0 ) ) ; |
| public final void ruleGridPropIndicatorStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:392:2: ( ( ( rule__GridPropIndicatorStyle__Group__0 ) ) ) |
| // InternalGridSource.g:393:2: ( ( rule__GridPropIndicatorStyle__Group__0 ) ) |
| { |
| // InternalGridSource.g:393:2: ( ( rule__GridPropIndicatorStyle__Group__0 ) ) |
| // InternalGridSource.g:394:3: ( rule__GridPropIndicatorStyle__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getGridPropIndicatorStyleAccess().getGroup()); |
| } |
| // InternalGridSource.g:395:3: ( rule__GridPropIndicatorStyle__Group__0 ) |
| // InternalGridSource.g:395:4: rule__GridPropIndicatorStyle__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__GridPropIndicatorStyle__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getGridPropIndicatorStyleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleGridPropIndicatorStyle" |
| |
| |
| // $ANTLR start "entryRulePropertyQuantityStyle" |
| // InternalGridSource.g:404:1: entryRulePropertyQuantityStyle : rulePropertyQuantityStyle EOF ; |
| public final void entryRulePropertyQuantityStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:405:1: ( rulePropertyQuantityStyle EOF ) |
| // InternalGridSource.g:406:1: rulePropertyQuantityStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| rulePropertyQuantityStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePropertyQuantityStyle" |
| |
| |
| // $ANTLR start "rulePropertyQuantityStyle" |
| // InternalGridSource.g:413:1: rulePropertyQuantityStyle : ( ( rule__PropertyQuantityStyle__Group__0 ) ) ; |
| public final void rulePropertyQuantityStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:417:2: ( ( ( rule__PropertyQuantityStyle__Group__0 ) ) ) |
| // InternalGridSource.g:418:2: ( ( rule__PropertyQuantityStyle__Group__0 ) ) |
| { |
| // InternalGridSource.g:418:2: ( ( rule__PropertyQuantityStyle__Group__0 ) ) |
| // InternalGridSource.g:419:3: ( rule__PropertyQuantityStyle__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getGroup()); |
| } |
| // InternalGridSource.g:420:3: ( rule__PropertyQuantityStyle__Group__0 ) |
| // InternalGridSource.g:420:4: rule__PropertyQuantityStyle__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePropertyQuantityStyle" |
| |
| |
| // $ANTLR start "entryRulePropertyPriceStyle" |
| // InternalGridSource.g:429:1: entryRulePropertyPriceStyle : rulePropertyPriceStyle EOF ; |
| public final void entryRulePropertyPriceStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:430:1: ( rulePropertyPriceStyle EOF ) |
| // InternalGridSource.g:431:1: rulePropertyPriceStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| rulePropertyPriceStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePropertyPriceStyle" |
| |
| |
| // $ANTLR start "rulePropertyPriceStyle" |
| // InternalGridSource.g:438:1: rulePropertyPriceStyle : ( ( rule__PropertyPriceStyle__Group__0 ) ) ; |
| public final void rulePropertyPriceStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:442:2: ( ( ( rule__PropertyPriceStyle__Group__0 ) ) ) |
| // InternalGridSource.g:443:2: ( ( rule__PropertyPriceStyle__Group__0 ) ) |
| { |
| // InternalGridSource.g:443:2: ( ( rule__PropertyPriceStyle__Group__0 ) ) |
| // InternalGridSource.g:444:3: ( rule__PropertyPriceStyle__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getGroup()); |
| } |
| // InternalGridSource.g:445:3: ( rule__PropertyPriceStyle__Group__0 ) |
| // InternalGridSource.g:445:4: rule__PropertyPriceStyle__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePropertyPriceStyle" |
| |
| |
| // $ANTLR start "entryRulePropertyTextStyle" |
| // InternalGridSource.g:454:1: entryRulePropertyTextStyle : rulePropertyTextStyle EOF ; |
| public final void entryRulePropertyTextStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:455:1: ( rulePropertyTextStyle EOF ) |
| // InternalGridSource.g:456:1: rulePropertyTextStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyTextStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| rulePropertyTextStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyTextStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePropertyTextStyle" |
| |
| |
| // $ANTLR start "rulePropertyTextStyle" |
| // InternalGridSource.g:463:1: rulePropertyTextStyle : ( ( rule__PropertyTextStyle__Group__0 ) ) ; |
| public final void rulePropertyTextStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:467:2: ( ( ( rule__PropertyTextStyle__Group__0 ) ) ) |
| // InternalGridSource.g:468:2: ( ( rule__PropertyTextStyle__Group__0 ) ) |
| { |
| // InternalGridSource.g:468:2: ( ( rule__PropertyTextStyle__Group__0 ) ) |
| // InternalGridSource.g:469:3: ( rule__PropertyTextStyle__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyTextStyleAccess().getGroup()); |
| } |
| // InternalGridSource.g:470:3: ( rule__PropertyTextStyle__Group__0 ) |
| // InternalGridSource.g:470:4: rule__PropertyTextStyle__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyTextStyle__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyTextStyleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePropertyTextStyle" |
| |
| |
| // $ANTLR start "entryRulePropertyImageStyle" |
| // InternalGridSource.g:479:1: entryRulePropertyImageStyle : rulePropertyImageStyle EOF ; |
| public final void entryRulePropertyImageStyle() throws RecognitionException { |
| try { |
| // InternalGridSource.g:480:1: ( rulePropertyImageStyle EOF ) |
| // InternalGridSource.g:481:1: rulePropertyImageStyle EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| rulePropertyImageStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRulePropertyImageStyle" |
| |
| |
| // $ANTLR start "rulePropertyImageStyle" |
| // InternalGridSource.g:488:1: rulePropertyImageStyle : ( ( rule__PropertyImageStyle__Group__0 ) ) ; |
| public final void rulePropertyImageStyle() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:492:2: ( ( ( rule__PropertyImageStyle__Group__0 ) ) ) |
| // InternalGridSource.g:493:2: ( ( rule__PropertyImageStyle__Group__0 ) ) |
| { |
| // InternalGridSource.g:493:2: ( ( rule__PropertyImageStyle__Group__0 ) ) |
| // InternalGridSource.g:494:3: ( rule__PropertyImageStyle__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleAccess().getGroup()); |
| } |
| // InternalGridSource.g:495:3: ( rule__PropertyImageStyle__Group__0 ) |
| // InternalGridSource.g:495:4: rule__PropertyImageStyle__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyImageStyle__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rulePropertyImageStyle" |
| |
| |
| // $ANTLR start "entryRuleQualifiedName" |
| // InternalGridSource.g:504:1: entryRuleQualifiedName : ruleQualifiedName EOF ; |
| public final void entryRuleQualifiedName() throws RecognitionException { |
| try { |
| // InternalGridSource.g:505:1: ( ruleQualifiedName EOF ) |
| // InternalGridSource.g:506:1: ruleQualifiedName EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleQualifiedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleQualifiedName" |
| |
| |
| // $ANTLR start "ruleQualifiedName" |
| // InternalGridSource.g:513:1: ruleQualifiedName : ( ( rule__QualifiedName__Group__0 ) ) ; |
| public final void ruleQualifiedName() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:517:2: ( ( ( rule__QualifiedName__Group__0 ) ) ) |
| // InternalGridSource.g:518:2: ( ( rule__QualifiedName__Group__0 ) ) |
| { |
| // InternalGridSource.g:518:2: ( ( rule__QualifiedName__Group__0 ) ) |
| // InternalGridSource.g:519:3: ( rule__QualifiedName__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameAccess().getGroup()); |
| } |
| // InternalGridSource.g:520:3: ( rule__QualifiedName__Group__0 ) |
| // InternalGridSource.g:520:4: rule__QualifiedName__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__QualifiedName__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleQualifiedName" |
| |
| |
| // $ANTLR start "entryRuleValidID" |
| // InternalGridSource.g:529:1: entryRuleValidID : ruleValidID EOF ; |
| public final void entryRuleValidID() throws RecognitionException { |
| try { |
| // InternalGridSource.g:530:1: ( ruleValidID EOF ) |
| // InternalGridSource.g:531:1: ruleValidID EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getValidIDRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleValidID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getValidIDRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleValidID" |
| |
| |
| // $ANTLR start "ruleValidID" |
| // InternalGridSource.g:538:1: ruleValidID : ( RULE_ID ) ; |
| public final void ruleValidID() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:542:2: ( ( RULE_ID ) ) |
| // InternalGridSource.g:543:2: ( RULE_ID ) |
| { |
| // InternalGridSource.g:543:2: ( RULE_ID ) |
| // InternalGridSource.g:544:3: RULE_ID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); |
| } |
| match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleValidID" |
| |
| |
| // $ANTLR start "entryRuleStyleConfig" |
| // InternalGridSource.g:554:1: entryRuleStyleConfig : ruleStyleConfig EOF ; |
| public final void entryRuleStyleConfig() throws RecognitionException { |
| try { |
| // InternalGridSource.g:555:1: ( ruleStyleConfig EOF ) |
| // InternalGridSource.g:556:1: ruleStyleConfig EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStyleConfigRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleStyleConfig(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStyleConfigRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleStyleConfig" |
| |
| |
| // $ANTLR start "ruleStyleConfig" |
| // InternalGridSource.g:563:1: ruleStyleConfig : ( ( rule__StyleConfig__Alternatives ) ) ; |
| public final void ruleStyleConfig() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:567:2: ( ( ( rule__StyleConfig__Alternatives ) ) ) |
| // InternalGridSource.g:568:2: ( ( rule__StyleConfig__Alternatives ) ) |
| { |
| // InternalGridSource.g:568:2: ( ( rule__StyleConfig__Alternatives ) ) |
| // InternalGridSource.g:569:3: ( rule__StyleConfig__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStyleConfigAccess().getAlternatives()); |
| } |
| // InternalGridSource.g:570:3: ( rule__StyleConfig__Alternatives ) |
| // InternalGridSource.g:570:4: rule__StyleConfig__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__StyleConfig__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStyleConfigAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleStyleConfig" |
| |
| |
| // $ANTLR start "entryRuleNumericToResourceStyleConfig" |
| // InternalGridSource.g:579:1: entryRuleNumericToResourceStyleConfig : ruleNumericToResourceStyleConfig EOF ; |
| public final void entryRuleNumericToResourceStyleConfig() throws RecognitionException { |
| try { |
| // InternalGridSource.g:580:1: ( ruleNumericToResourceStyleConfig EOF ) |
| // InternalGridSource.g:581:1: ruleNumericToResourceStyleConfig EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumericToResourceStyleConfigRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleNumericToResourceStyleConfig(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumericToResourceStyleConfigRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNumericToResourceStyleConfig" |
| |
| |
| // $ANTLR start "ruleNumericToResourceStyleConfig" |
| // InternalGridSource.g:588:1: ruleNumericToResourceStyleConfig : ( ( rule__NumericToResourceStyleConfig__Group__0 ) ) ; |
| public final void ruleNumericToResourceStyleConfig() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:592:2: ( ( ( rule__NumericToResourceStyleConfig__Group__0 ) ) ) |
| // InternalGridSource.g:593:2: ( ( rule__NumericToResourceStyleConfig__Group__0 ) ) |
| { |
| // InternalGridSource.g:593:2: ( ( rule__NumericToResourceStyleConfig__Group__0 ) ) |
| // InternalGridSource.g:594:3: ( rule__NumericToResourceStyleConfig__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumericToResourceStyleConfigAccess().getGroup()); |
| } |
| // InternalGridSource.g:595:3: ( rule__NumericToResourceStyleConfig__Group__0 ) |
| // InternalGridSource.g:595:4: rule__NumericToResourceStyleConfig__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__NumericToResourceStyleConfig__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumericToResourceStyleConfigAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNumericToResourceStyleConfig" |
| |
| |
| // $ANTLR start "entryRuleStringToResourceStyleConfig" |
| // InternalGridSource.g:604:1: entryRuleStringToResourceStyleConfig : ruleStringToResourceStyleConfig EOF ; |
| public final void entryRuleStringToResourceStyleConfig() throws RecognitionException { |
| try { |
| // InternalGridSource.g:605:1: ( ruleStringToResourceStyleConfig EOF ) |
| // InternalGridSource.g:606:1: ruleStringToResourceStyleConfig EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringToResourceStyleConfigRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleStringToResourceStyleConfig(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringToResourceStyleConfigRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleStringToResourceStyleConfig" |
| |
| |
| // $ANTLR start "ruleStringToResourceStyleConfig" |
| // InternalGridSource.g:613:1: ruleStringToResourceStyleConfig : ( ( rule__StringToResourceStyleConfig__Group__0 ) ) ; |
| public final void ruleStringToResourceStyleConfig() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:617:2: ( ( ( rule__StringToResourceStyleConfig__Group__0 ) ) ) |
| // InternalGridSource.g:618:2: ( ( rule__StringToResourceStyleConfig__Group__0 ) ) |
| { |
| // InternalGridSource.g:618:2: ( ( rule__StringToResourceStyleConfig__Group__0 ) ) |
| // InternalGridSource.g:619:3: ( rule__StringToResourceStyleConfig__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringToResourceStyleConfigAccess().getGroup()); |
| } |
| // InternalGridSource.g:620:3: ( rule__StringToResourceStyleConfig__Group__0 ) |
| // InternalGridSource.g:620:4: rule__StringToResourceStyleConfig__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StringToResourceStyleConfig__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringToResourceStyleConfigAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleStringToResourceStyleConfig" |
| |
| |
| // $ANTLR start "entryRuleLInt" |
| // InternalGridSource.g:629:1: entryRuleLInt : ruleLInt EOF ; |
| public final void entryRuleLInt() throws RecognitionException { |
| try { |
| // InternalGridSource.g:630:1: ( ruleLInt EOF ) |
| // InternalGridSource.g:631:1: ruleLInt EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLIntRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleLInt(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLIntRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLInt" |
| |
| |
| // $ANTLR start "ruleLInt" |
| // InternalGridSource.g:638:1: ruleLInt : ( ( rule__LInt__Group__0 ) ) ; |
| public final void ruleLInt() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:642:2: ( ( ( rule__LInt__Group__0 ) ) ) |
| // InternalGridSource.g:643:2: ( ( rule__LInt__Group__0 ) ) |
| { |
| // InternalGridSource.g:643:2: ( ( rule__LInt__Group__0 ) ) |
| // InternalGridSource.g:644:3: ( rule__LInt__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLIntAccess().getGroup()); |
| } |
| // InternalGridSource.g:645:3: ( rule__LInt__Group__0 ) |
| // InternalGridSource.g:645:4: rule__LInt__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__LInt__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLIntAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLInt" |
| |
| |
| // $ANTLR start "entryRuleLDouble" |
| // InternalGridSource.g:654:1: entryRuleLDouble : ruleLDouble EOF ; |
| public final void entryRuleLDouble() throws RecognitionException { |
| try { |
| // InternalGridSource.g:655:1: ( ruleLDouble EOF ) |
| // InternalGridSource.g:656:1: ruleLDouble EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLDoubleRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleLDouble(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLDoubleRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLDouble" |
| |
| |
| // $ANTLR start "ruleLDouble" |
| // InternalGridSource.g:663:1: ruleLDouble : ( ( rule__LDouble__Group__0 ) ) ; |
| public final void ruleLDouble() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:667:2: ( ( ( rule__LDouble__Group__0 ) ) ) |
| // InternalGridSource.g:668:2: ( ( rule__LDouble__Group__0 ) ) |
| { |
| // InternalGridSource.g:668:2: ( ( rule__LDouble__Group__0 ) ) |
| // InternalGridSource.g:669:3: ( rule__LDouble__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLDoubleAccess().getGroup()); |
| } |
| // InternalGridSource.g:670:3: ( rule__LDouble__Group__0 ) |
| // InternalGridSource.g:670:4: rule__LDouble__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__LDouble__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLDoubleAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLDouble" |
| |
| |
| // $ANTLR start "entryRuleJvmTypeReference" |
| // InternalGridSource.g:679:1: entryRuleJvmTypeReference : ruleJvmTypeReference EOF ; |
| public final void entryRuleJvmTypeReference() throws RecognitionException { |
| try { |
| // InternalGridSource.g:680:1: ( ruleJvmTypeReference EOF ) |
| // InternalGridSource.g:681:1: ruleJvmTypeReference EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmTypeReferenceRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleJvmTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmTypeReferenceRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleJvmTypeReference" |
| |
| |
| // $ANTLR start "ruleJvmTypeReference" |
| // InternalGridSource.g:688:1: ruleJvmTypeReference : ( ( rule__JvmTypeReference__Alternatives ) ) ; |
| public final void ruleJvmTypeReference() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:692:2: ( ( ( rule__JvmTypeReference__Alternatives ) ) ) |
| // InternalGridSource.g:693:2: ( ( rule__JvmTypeReference__Alternatives ) ) |
| { |
| // InternalGridSource.g:693:2: ( ( rule__JvmTypeReference__Alternatives ) ) |
| // InternalGridSource.g:694:3: ( rule__JvmTypeReference__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); |
| } |
| // InternalGridSource.g:695:3: ( rule__JvmTypeReference__Alternatives ) |
| // InternalGridSource.g:695:4: rule__JvmTypeReference__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmTypeReference__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleJvmTypeReference" |
| |
| |
| // $ANTLR start "entryRuleArrayBrackets" |
| // InternalGridSource.g:704:1: entryRuleArrayBrackets : ruleArrayBrackets EOF ; |
| public final void entryRuleArrayBrackets() throws RecognitionException { |
| try { |
| // InternalGridSource.g:705:1: ( ruleArrayBrackets EOF ) |
| // InternalGridSource.g:706:1: ruleArrayBrackets EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getArrayBracketsRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleArrayBrackets(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getArrayBracketsRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleArrayBrackets" |
| |
| |
| // $ANTLR start "ruleArrayBrackets" |
| // InternalGridSource.g:713:1: ruleArrayBrackets : ( ( rule__ArrayBrackets__Group__0 ) ) ; |
| public final void ruleArrayBrackets() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:717:2: ( ( ( rule__ArrayBrackets__Group__0 ) ) ) |
| // InternalGridSource.g:718:2: ( ( rule__ArrayBrackets__Group__0 ) ) |
| { |
| // InternalGridSource.g:718:2: ( ( rule__ArrayBrackets__Group__0 ) ) |
| // InternalGridSource.g:719:3: ( rule__ArrayBrackets__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getArrayBracketsAccess().getGroup()); |
| } |
| // InternalGridSource.g:720:3: ( rule__ArrayBrackets__Group__0 ) |
| // InternalGridSource.g:720:4: rule__ArrayBrackets__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ArrayBrackets__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getArrayBracketsAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleArrayBrackets" |
| |
| |
| // $ANTLR start "entryRuleXFunctionTypeRef" |
| // InternalGridSource.g:729:1: entryRuleXFunctionTypeRef : ruleXFunctionTypeRef EOF ; |
| public final void entryRuleXFunctionTypeRef() throws RecognitionException { |
| try { |
| // InternalGridSource.g:730:1: ( ruleXFunctionTypeRef EOF ) |
| // InternalGridSource.g:731:1: ruleXFunctionTypeRef EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleXFunctionTypeRef(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleXFunctionTypeRef" |
| |
| |
| // $ANTLR start "ruleXFunctionTypeRef" |
| // InternalGridSource.g:738:1: ruleXFunctionTypeRef : ( ( rule__XFunctionTypeRef__Group__0 ) ) ; |
| public final void ruleXFunctionTypeRef() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:742:2: ( ( ( rule__XFunctionTypeRef__Group__0 ) ) ) |
| // InternalGridSource.g:743:2: ( ( rule__XFunctionTypeRef__Group__0 ) ) |
| { |
| // InternalGridSource.g:743:2: ( ( rule__XFunctionTypeRef__Group__0 ) ) |
| // InternalGridSource.g:744:3: ( rule__XFunctionTypeRef__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); |
| } |
| // InternalGridSource.g:745:3: ( rule__XFunctionTypeRef__Group__0 ) |
| // InternalGridSource.g:745:4: rule__XFunctionTypeRef__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleXFunctionTypeRef" |
| |
| |
| // $ANTLR start "entryRuleJvmParameterizedTypeReference" |
| // InternalGridSource.g:754:1: entryRuleJvmParameterizedTypeReference : ruleJvmParameterizedTypeReference EOF ; |
| public final void entryRuleJvmParameterizedTypeReference() throws RecognitionException { |
| try { |
| // InternalGridSource.g:755:1: ( ruleJvmParameterizedTypeReference EOF ) |
| // InternalGridSource.g:756:1: ruleJvmParameterizedTypeReference EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleJvmParameterizedTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleJvmParameterizedTypeReference" |
| |
| |
| // $ANTLR start "ruleJvmParameterizedTypeReference" |
| // InternalGridSource.g:763:1: ruleJvmParameterizedTypeReference : ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ; |
| public final void ruleJvmParameterizedTypeReference() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:767:2: ( ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ) |
| // InternalGridSource.g:768:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) |
| { |
| // InternalGridSource.g:768:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) |
| // InternalGridSource.g:769:3: ( rule__JvmParameterizedTypeReference__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); |
| } |
| // InternalGridSource.g:770:3: ( rule__JvmParameterizedTypeReference__Group__0 ) |
| // InternalGridSource.g:770:4: rule__JvmParameterizedTypeReference__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleJvmParameterizedTypeReference" |
| |
| |
| // $ANTLR start "entryRuleJvmArgumentTypeReference" |
| // InternalGridSource.g:779:1: entryRuleJvmArgumentTypeReference : ruleJvmArgumentTypeReference EOF ; |
| public final void entryRuleJvmArgumentTypeReference() throws RecognitionException { |
| try { |
| // InternalGridSource.g:780:1: ( ruleJvmArgumentTypeReference EOF ) |
| // InternalGridSource.g:781:1: ruleJvmArgumentTypeReference EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmArgumentTypeReferenceRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleJvmArgumentTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmArgumentTypeReferenceRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleJvmArgumentTypeReference" |
| |
| |
| // $ANTLR start "ruleJvmArgumentTypeReference" |
| // InternalGridSource.g:788:1: ruleJvmArgumentTypeReference : ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ; |
| public final void ruleJvmArgumentTypeReference() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:792:2: ( ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ) |
| // InternalGridSource.g:793:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) ) |
| { |
| // InternalGridSource.g:793:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) ) |
| // InternalGridSource.g:794:3: ( rule__JvmArgumentTypeReference__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); |
| } |
| // InternalGridSource.g:795:3: ( rule__JvmArgumentTypeReference__Alternatives ) |
| // InternalGridSource.g:795:4: rule__JvmArgumentTypeReference__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmArgumentTypeReference__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleJvmArgumentTypeReference" |
| |
| |
| // $ANTLR start "entryRuleJvmWildcardTypeReference" |
| // InternalGridSource.g:804:1: entryRuleJvmWildcardTypeReference : ruleJvmWildcardTypeReference EOF ; |
| public final void entryRuleJvmWildcardTypeReference() throws RecognitionException { |
| try { |
| // InternalGridSource.g:805:1: ( ruleJvmWildcardTypeReference EOF ) |
| // InternalGridSource.g:806:1: ruleJvmWildcardTypeReference EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleJvmWildcardTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleJvmWildcardTypeReference" |
| |
| |
| // $ANTLR start "ruleJvmWildcardTypeReference" |
| // InternalGridSource.g:813:1: ruleJvmWildcardTypeReference : ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ; |
| public final void ruleJvmWildcardTypeReference() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:817:2: ( ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ) |
| // InternalGridSource.g:818:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) ) |
| { |
| // InternalGridSource.g:818:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) ) |
| // InternalGridSource.g:819:3: ( rule__JvmWildcardTypeReference__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); |
| } |
| // InternalGridSource.g:820:3: ( rule__JvmWildcardTypeReference__Group__0 ) |
| // InternalGridSource.g:820:4: rule__JvmWildcardTypeReference__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleJvmWildcardTypeReference" |
| |
| |
| // $ANTLR start "entryRuleJvmUpperBound" |
| // InternalGridSource.g:829:1: entryRuleJvmUpperBound : ruleJvmUpperBound EOF ; |
| public final void entryRuleJvmUpperBound() throws RecognitionException { |
| try { |
| // InternalGridSource.g:830:1: ( ruleJvmUpperBound EOF ) |
| // InternalGridSource.g:831:1: ruleJvmUpperBound EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmUpperBoundRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleJvmUpperBound(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmUpperBoundRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleJvmUpperBound" |
| |
| |
| // $ANTLR start "ruleJvmUpperBound" |
| // InternalGridSource.g:838:1: ruleJvmUpperBound : ( ( rule__JvmUpperBound__Group__0 ) ) ; |
| public final void ruleJvmUpperBound() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:842:2: ( ( ( rule__JvmUpperBound__Group__0 ) ) ) |
| // InternalGridSource.g:843:2: ( ( rule__JvmUpperBound__Group__0 ) ) |
| { |
| // InternalGridSource.g:843:2: ( ( rule__JvmUpperBound__Group__0 ) ) |
| // InternalGridSource.g:844:3: ( rule__JvmUpperBound__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmUpperBoundAccess().getGroup()); |
| } |
| // InternalGridSource.g:845:3: ( rule__JvmUpperBound__Group__0 ) |
| // InternalGridSource.g:845:4: rule__JvmUpperBound__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmUpperBound__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmUpperBoundAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleJvmUpperBound" |
| |
| |
| // $ANTLR start "entryRuleJvmUpperBoundAnded" |
| // InternalGridSource.g:854:1: entryRuleJvmUpperBoundAnded : ruleJvmUpperBoundAnded EOF ; |
| public final void entryRuleJvmUpperBoundAnded() throws RecognitionException { |
| try { |
| // InternalGridSource.g:855:1: ( ruleJvmUpperBoundAnded EOF ) |
| // InternalGridSource.g:856:1: ruleJvmUpperBoundAnded EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmUpperBoundAndedRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleJvmUpperBoundAnded(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmUpperBoundAndedRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleJvmUpperBoundAnded" |
| |
| |
| // $ANTLR start "ruleJvmUpperBoundAnded" |
| // InternalGridSource.g:863:1: ruleJvmUpperBoundAnded : ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ; |
| public final void ruleJvmUpperBoundAnded() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:867:2: ( ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ) |
| // InternalGridSource.g:868:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) ) |
| { |
| // InternalGridSource.g:868:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) ) |
| // InternalGridSource.g:869:3: ( rule__JvmUpperBoundAnded__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); |
| } |
| // InternalGridSource.g:870:3: ( rule__JvmUpperBoundAnded__Group__0 ) |
| // InternalGridSource.g:870:4: rule__JvmUpperBoundAnded__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmUpperBoundAnded__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleJvmUpperBoundAnded" |
| |
| |
| // $ANTLR start "entryRuleJvmLowerBound" |
| // InternalGridSource.g:879:1: entryRuleJvmLowerBound : ruleJvmLowerBound EOF ; |
| public final void entryRuleJvmLowerBound() throws RecognitionException { |
| try { |
| // InternalGridSource.g:880:1: ( ruleJvmLowerBound EOF ) |
| // InternalGridSource.g:881:1: ruleJvmLowerBound EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmLowerBoundRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleJvmLowerBound(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmLowerBoundRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleJvmLowerBound" |
| |
| |
| // $ANTLR start "ruleJvmLowerBound" |
| // InternalGridSource.g:888:1: ruleJvmLowerBound : ( ( rule__JvmLowerBound__Group__0 ) ) ; |
| public final void ruleJvmLowerBound() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:892:2: ( ( ( rule__JvmLowerBound__Group__0 ) ) ) |
| // InternalGridSource.g:893:2: ( ( rule__JvmLowerBound__Group__0 ) ) |
| { |
| // InternalGridSource.g:893:2: ( ( rule__JvmLowerBound__Group__0 ) ) |
| // InternalGridSource.g:894:3: ( rule__JvmLowerBound__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmLowerBoundAccess().getGroup()); |
| } |
| // InternalGridSource.g:895:3: ( rule__JvmLowerBound__Group__0 ) |
| // InternalGridSource.g:895:4: rule__JvmLowerBound__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmLowerBound__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmLowerBoundAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleJvmLowerBound" |
| |
| |
| // $ANTLR start "entryRuleJvmLowerBoundAnded" |
| // InternalGridSource.g:904:1: entryRuleJvmLowerBoundAnded : ruleJvmLowerBoundAnded EOF ; |
| public final void entryRuleJvmLowerBoundAnded() throws RecognitionException { |
| try { |
| // InternalGridSource.g:905:1: ( ruleJvmLowerBoundAnded EOF ) |
| // InternalGridSource.g:906:1: ruleJvmLowerBoundAnded EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmLowerBoundAndedRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleJvmLowerBoundAnded(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmLowerBoundAndedRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleJvmLowerBoundAnded" |
| |
| |
| // $ANTLR start "ruleJvmLowerBoundAnded" |
| // InternalGridSource.g:913:1: ruleJvmLowerBoundAnded : ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ; |
| public final void ruleJvmLowerBoundAnded() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:917:2: ( ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ) |
| // InternalGridSource.g:918:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) ) |
| { |
| // InternalGridSource.g:918:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) ) |
| // InternalGridSource.g:919:3: ( rule__JvmLowerBoundAnded__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); |
| } |
| // InternalGridSource.g:920:3: ( rule__JvmLowerBoundAnded__Group__0 ) |
| // InternalGridSource.g:920:4: rule__JvmLowerBoundAnded__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmLowerBoundAnded__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleJvmLowerBoundAnded" |
| |
| |
| // $ANTLR start "entryRuleQualifiedNameWithWildcard" |
| // InternalGridSource.g:929:1: entryRuleQualifiedNameWithWildcard : ruleQualifiedNameWithWildcard EOF ; |
| public final void entryRuleQualifiedNameWithWildcard() throws RecognitionException { |
| try { |
| // InternalGridSource.g:930:1: ( ruleQualifiedNameWithWildcard EOF ) |
| // InternalGridSource.g:931:1: ruleQualifiedNameWithWildcard EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameWithWildcardRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleQualifiedNameWithWildcard(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameWithWildcardRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleQualifiedNameWithWildcard" |
| |
| |
| // $ANTLR start "ruleQualifiedNameWithWildcard" |
| // InternalGridSource.g:938:1: ruleQualifiedNameWithWildcard : ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ; |
| public final void ruleQualifiedNameWithWildcard() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:942:2: ( ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ) |
| // InternalGridSource.g:943:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) |
| { |
| // InternalGridSource.g:943:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) |
| // InternalGridSource.g:944:3: ( rule__QualifiedNameWithWildcard__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); |
| } |
| // InternalGridSource.g:945:3: ( rule__QualifiedNameWithWildcard__Group__0 ) |
| // InternalGridSource.g:945:4: rule__QualifiedNameWithWildcard__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__QualifiedNameWithWildcard__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleQualifiedNameWithWildcard" |
| |
| |
| // $ANTLR start "entryRuleXImportDeclaration" |
| // InternalGridSource.g:954:1: entryRuleXImportDeclaration : ruleXImportDeclaration EOF ; |
| public final void entryRuleXImportDeclaration() throws RecognitionException { |
| try { |
| // InternalGridSource.g:955:1: ( ruleXImportDeclaration EOF ) |
| // InternalGridSource.g:956:1: ruleXImportDeclaration EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleXImportDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleXImportDeclaration" |
| |
| |
| // $ANTLR start "ruleXImportDeclaration" |
| // InternalGridSource.g:963:1: ruleXImportDeclaration : ( ( rule__XImportDeclaration__Group__0 ) ) ; |
| public final void ruleXImportDeclaration() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:967:2: ( ( ( rule__XImportDeclaration__Group__0 ) ) ) |
| // InternalGridSource.g:968:2: ( ( rule__XImportDeclaration__Group__0 ) ) |
| { |
| // InternalGridSource.g:968:2: ( ( rule__XImportDeclaration__Group__0 ) ) |
| // InternalGridSource.g:969:3: ( rule__XImportDeclaration__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getGroup()); |
| } |
| // InternalGridSource.g:970:3: ( rule__XImportDeclaration__Group__0 ) |
| // InternalGridSource.g:970:4: rule__XImportDeclaration__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleXImportDeclaration" |
| |
| |
| // $ANTLR start "entryRuleQualifiedNameInStaticImport" |
| // InternalGridSource.g:979:1: entryRuleQualifiedNameInStaticImport : ruleQualifiedNameInStaticImport EOF ; |
| public final void entryRuleQualifiedNameInStaticImport() throws RecognitionException { |
| try { |
| // InternalGridSource.g:980:1: ( ruleQualifiedNameInStaticImport EOF ) |
| // InternalGridSource.g:981:1: ruleQualifiedNameInStaticImport EOF |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameInStaticImportRule()); |
| } |
| pushFollow(FOLLOW_1); |
| ruleQualifiedNameInStaticImport(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameInStaticImportRule()); |
| } |
| match(input,EOF,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleQualifiedNameInStaticImport" |
| |
| |
| // $ANTLR start "ruleQualifiedNameInStaticImport" |
| // InternalGridSource.g:988:1: ruleQualifiedNameInStaticImport : ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ; |
| public final void ruleQualifiedNameInStaticImport() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:992:2: ( ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ) |
| // InternalGridSource.g:993:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) |
| { |
| // InternalGridSource.g:993:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) |
| // InternalGridSource.g:994:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) |
| { |
| // InternalGridSource.g:994:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) |
| // InternalGridSource.g:995:4: ( rule__QualifiedNameInStaticImport__Group__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); |
| } |
| // InternalGridSource.g:996:4: ( rule__QualifiedNameInStaticImport__Group__0 ) |
| // InternalGridSource.g:996:5: rule__QualifiedNameInStaticImport__Group__0 |
| { |
| pushFollow(FOLLOW_3); |
| rule__QualifiedNameInStaticImport__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); |
| } |
| |
| } |
| |
| // InternalGridSource.g:999:3: ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) |
| // InternalGridSource.g:1000:4: ( rule__QualifiedNameInStaticImport__Group__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); |
| } |
| // InternalGridSource.g:1001:4: ( rule__QualifiedNameInStaticImport__Group__0 )* |
| loop1: |
| do { |
| int alt1=2; |
| int LA1_0 = input.LA(1); |
| |
| if ( (LA1_0==RULE_ID) ) { |
| int LA1_2 = input.LA(2); |
| |
| if ( (LA1_2==34) ) { |
| alt1=1; |
| } |
| |
| |
| } |
| |
| |
| switch (alt1) { |
| case 1 : |
| // InternalGridSource.g:1001:5: rule__QualifiedNameInStaticImport__Group__0 |
| { |
| pushFollow(FOLLOW_3); |
| rule__QualifiedNameInStaticImport__Group__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop1; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); |
| } |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleQualifiedNameInStaticImport" |
| |
| |
| // $ANTLR start "ruleStyleCompare" |
| // InternalGridSource.g:1011:1: ruleStyleCompare : ( ( rule__StyleCompare__Alternatives ) ) ; |
| public final void ruleStyleCompare() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1015:1: ( ( ( rule__StyleCompare__Alternatives ) ) ) |
| // InternalGridSource.g:1016:2: ( ( rule__StyleCompare__Alternatives ) ) |
| { |
| // InternalGridSource.g:1016:2: ( ( rule__StyleCompare__Alternatives ) ) |
| // InternalGridSource.g:1017:3: ( rule__StyleCompare__Alternatives ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStyleCompareAccess().getAlternatives()); |
| } |
| // InternalGridSource.g:1018:3: ( rule__StyleCompare__Alternatives ) |
| // InternalGridSource.g:1018:4: rule__StyleCompare__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__StyleCompare__Alternatives(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStyleCompareAccess().getAlternatives()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleStyleCompare" |
| |
| |
| // $ANTLR start "rule__PropertyStyle__Alternatives" |
| // InternalGridSource.g:1026:1: rule__PropertyStyle__Alternatives : ( ( rulePropertyButtonStyle ) | ( rulePropertyHtmlStyle ) | ( rulePropertyProgressbarStyle ) | ( rulePropertyTextStyle ) | ( rulePropertyBooleanStyle ) | ( rulePropertyDateStyle ) | ( rulePropertyNumberStyle ) | ( rulePropertyImageStyle ) | ( rulePropertyQuantityStyle ) | ( rulePropertyPriceStyle ) | ( ruleGridPropIndicatorStyle ) ); |
| public final void rule__PropertyStyle__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1030:1: ( ( rulePropertyButtonStyle ) | ( rulePropertyHtmlStyle ) | ( rulePropertyProgressbarStyle ) | ( rulePropertyTextStyle ) | ( rulePropertyBooleanStyle ) | ( rulePropertyDateStyle ) | ( rulePropertyNumberStyle ) | ( rulePropertyImageStyle ) | ( rulePropertyQuantityStyle ) | ( rulePropertyPriceStyle ) | ( ruleGridPropIndicatorStyle ) ) |
| int alt2=11; |
| switch ( input.LA(1) ) { |
| case 35: |
| { |
| alt2=1; |
| } |
| break; |
| case 37: |
| { |
| alt2=2; |
| } |
| break; |
| case 42: |
| { |
| alt2=3; |
| } |
| break; |
| case 54: |
| { |
| alt2=4; |
| } |
| break; |
| case 38: |
| { |
| alt2=5; |
| } |
| break; |
| case 39: |
| { |
| alt2=6; |
| } |
| break; |
| case 41: |
| { |
| alt2=7; |
| } |
| break; |
| case 55: |
| { |
| alt2=8; |
| } |
| break; |
| case 47: |
| { |
| alt2=9; |
| } |
| break; |
| case 52: |
| { |
| alt2=10; |
| } |
| break; |
| case 44: |
| { |
| alt2=11; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 2, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt2) { |
| case 1 : |
| // InternalGridSource.g:1031:2: ( rulePropertyButtonStyle ) |
| { |
| // InternalGridSource.g:1031:2: ( rulePropertyButtonStyle ) |
| // InternalGridSource.g:1032:3: rulePropertyButtonStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getPropertyButtonStyleParserRuleCall_0()); |
| } |
| pushFollow(FOLLOW_2); |
| rulePropertyButtonStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getPropertyButtonStyleParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalGridSource.g:1037:2: ( rulePropertyHtmlStyle ) |
| { |
| // InternalGridSource.g:1037:2: ( rulePropertyHtmlStyle ) |
| // InternalGridSource.g:1038:3: rulePropertyHtmlStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getPropertyHtmlStyleParserRuleCall_1()); |
| } |
| pushFollow(FOLLOW_2); |
| rulePropertyHtmlStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getPropertyHtmlStyleParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalGridSource.g:1043:2: ( rulePropertyProgressbarStyle ) |
| { |
| // InternalGridSource.g:1043:2: ( rulePropertyProgressbarStyle ) |
| // InternalGridSource.g:1044:3: rulePropertyProgressbarStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getPropertyProgressbarStyleParserRuleCall_2()); |
| } |
| pushFollow(FOLLOW_2); |
| rulePropertyProgressbarStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getPropertyProgressbarStyleParserRuleCall_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalGridSource.g:1049:2: ( rulePropertyTextStyle ) |
| { |
| // InternalGridSource.g:1049:2: ( rulePropertyTextStyle ) |
| // InternalGridSource.g:1050:3: rulePropertyTextStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getPropertyTextStyleParserRuleCall_3()); |
| } |
| pushFollow(FOLLOW_2); |
| rulePropertyTextStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getPropertyTextStyleParserRuleCall_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalGridSource.g:1055:2: ( rulePropertyBooleanStyle ) |
| { |
| // InternalGridSource.g:1055:2: ( rulePropertyBooleanStyle ) |
| // InternalGridSource.g:1056:3: rulePropertyBooleanStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getPropertyBooleanStyleParserRuleCall_4()); |
| } |
| pushFollow(FOLLOW_2); |
| rulePropertyBooleanStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getPropertyBooleanStyleParserRuleCall_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 6 : |
| // InternalGridSource.g:1061:2: ( rulePropertyDateStyle ) |
| { |
| // InternalGridSource.g:1061:2: ( rulePropertyDateStyle ) |
| // InternalGridSource.g:1062:3: rulePropertyDateStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getPropertyDateStyleParserRuleCall_5()); |
| } |
| pushFollow(FOLLOW_2); |
| rulePropertyDateStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getPropertyDateStyleParserRuleCall_5()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 7 : |
| // InternalGridSource.g:1067:2: ( rulePropertyNumberStyle ) |
| { |
| // InternalGridSource.g:1067:2: ( rulePropertyNumberStyle ) |
| // InternalGridSource.g:1068:3: rulePropertyNumberStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getPropertyNumberStyleParserRuleCall_6()); |
| } |
| pushFollow(FOLLOW_2); |
| rulePropertyNumberStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getPropertyNumberStyleParserRuleCall_6()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 8 : |
| // InternalGridSource.g:1073:2: ( rulePropertyImageStyle ) |
| { |
| // InternalGridSource.g:1073:2: ( rulePropertyImageStyle ) |
| // InternalGridSource.g:1074:3: rulePropertyImageStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getPropertyImageStyleParserRuleCall_7()); |
| } |
| pushFollow(FOLLOW_2); |
| rulePropertyImageStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getPropertyImageStyleParserRuleCall_7()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 9 : |
| // InternalGridSource.g:1079:2: ( rulePropertyQuantityStyle ) |
| { |
| // InternalGridSource.g:1079:2: ( rulePropertyQuantityStyle ) |
| // InternalGridSource.g:1080:3: rulePropertyQuantityStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getPropertyQuantityStyleParserRuleCall_8()); |
| } |
| pushFollow(FOLLOW_2); |
| rulePropertyQuantityStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getPropertyQuantityStyleParserRuleCall_8()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 10 : |
| // InternalGridSource.g:1085:2: ( rulePropertyPriceStyle ) |
| { |
| // InternalGridSource.g:1085:2: ( rulePropertyPriceStyle ) |
| // InternalGridSource.g:1086:3: rulePropertyPriceStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getPropertyPriceStyleParserRuleCall_9()); |
| } |
| pushFollow(FOLLOW_2); |
| rulePropertyPriceStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getPropertyPriceStyleParserRuleCall_9()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 11 : |
| // InternalGridSource.g:1091:2: ( ruleGridPropIndicatorStyle ) |
| { |
| // InternalGridSource.g:1091:2: ( ruleGridPropIndicatorStyle ) |
| // InternalGridSource.g:1092:3: ruleGridPropIndicatorStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyStyleAccess().getGridPropIndicatorStyleParserRuleCall_10()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleGridPropIndicatorStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyStyleAccess().getGridPropIndicatorStyleParserRuleCall_10()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyStyle__Alternatives" |
| |
| |
| // $ANTLR start "rule__StyleConfig__Alternatives" |
| // InternalGridSource.g:1101:1: rule__StyleConfig__Alternatives : ( ( ruleNumericToResourceStyleConfig ) | ( ruleStringToResourceStyleConfig ) ); |
| public final void rule__StyleConfig__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1105:1: ( ( ruleNumericToResourceStyleConfig ) | ( ruleStringToResourceStyleConfig ) ) |
| int alt3=2; |
| int LA3_0 = input.LA(1); |
| |
| if ( (LA3_0==56) ) { |
| alt3=1; |
| } |
| else if ( (LA3_0==58) ) { |
| alt3=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 3, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt3) { |
| case 1 : |
| // InternalGridSource.g:1106:2: ( ruleNumericToResourceStyleConfig ) |
| { |
| // InternalGridSource.g:1106:2: ( ruleNumericToResourceStyleConfig ) |
| // InternalGridSource.g:1107:3: ruleNumericToResourceStyleConfig |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStyleConfigAccess().getNumericToResourceStyleConfigParserRuleCall_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleNumericToResourceStyleConfig(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStyleConfigAccess().getNumericToResourceStyleConfigParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalGridSource.g:1112:2: ( ruleStringToResourceStyleConfig ) |
| { |
| // InternalGridSource.g:1112:2: ( ruleStringToResourceStyleConfig ) |
| // InternalGridSource.g:1113:3: ruleStringToResourceStyleConfig |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStyleConfigAccess().getStringToResourceStyleConfigParserRuleCall_1()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleStringToResourceStyleConfig(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStyleConfigAccess().getStringToResourceStyleConfigParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StyleConfig__Alternatives" |
| |
| |
| // $ANTLR start "rule__LInt__Alternatives_0" |
| // InternalGridSource.g:1122:1: rule__LInt__Alternatives_0 : ( ( '+' ) | ( '-' ) ); |
| public final void rule__LInt__Alternatives_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1126:1: ( ( '+' ) | ( '-' ) ) |
| int alt4=2; |
| int LA4_0 = input.LA(1); |
| |
| if ( (LA4_0==13) ) { |
| alt4=1; |
| } |
| else if ( (LA4_0==14) ) { |
| alt4=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 4, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt4) { |
| case 1 : |
| // InternalGridSource.g:1127:2: ( '+' ) |
| { |
| // InternalGridSource.g:1127:2: ( '+' ) |
| // InternalGridSource.g:1128:3: '+' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLIntAccess().getPlusSignKeyword_0_0()); |
| } |
| match(input,13,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLIntAccess().getPlusSignKeyword_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalGridSource.g:1133:2: ( '-' ) |
| { |
| // InternalGridSource.g:1133:2: ( '-' ) |
| // InternalGridSource.g:1134:3: '-' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLIntAccess().getHyphenMinusKeyword_0_1()); |
| } |
| match(input,14,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLIntAccess().getHyphenMinusKeyword_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LInt__Alternatives_0" |
| |
| |
| // $ANTLR start "rule__JvmTypeReference__Alternatives" |
| // InternalGridSource.g:1143:1: rule__JvmTypeReference__Alternatives : ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) ); |
| public final void rule__JvmTypeReference__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1147:1: ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) ) |
| int alt5=2; |
| int LA5_0 = input.LA(1); |
| |
| if ( (LA5_0==RULE_ID) ) { |
| alt5=1; |
| } |
| else if ( (LA5_0==50||LA5_0==61) ) { |
| alt5=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 5, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt5) { |
| case 1 : |
| // InternalGridSource.g:1148:2: ( ( rule__JvmTypeReference__Group_0__0 ) ) |
| { |
| // InternalGridSource.g:1148:2: ( ( rule__JvmTypeReference__Group_0__0 ) ) |
| // InternalGridSource.g:1149:3: ( rule__JvmTypeReference__Group_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); |
| } |
| // InternalGridSource.g:1150:3: ( rule__JvmTypeReference__Group_0__0 ) |
| // InternalGridSource.g:1150:4: rule__JvmTypeReference__Group_0__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmTypeReference__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalGridSource.g:1154:2: ( ruleXFunctionTypeRef ) |
| { |
| // InternalGridSource.g:1154:2: ( ruleXFunctionTypeRef ) |
| // InternalGridSource.g:1155:3: ruleXFunctionTypeRef |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleXFunctionTypeRef(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmTypeReference__Alternatives" |
| |
| |
| // $ANTLR start "rule__JvmArgumentTypeReference__Alternatives" |
| // InternalGridSource.g:1164:1: rule__JvmArgumentTypeReference__Alternatives : ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) ); |
| public final void rule__JvmArgumentTypeReference__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1168:1: ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) ) |
| int alt6=2; |
| int LA6_0 = input.LA(1); |
| |
| if ( (LA6_0==RULE_ID||LA6_0==50||LA6_0==61) ) { |
| alt6=1; |
| } |
| else if ( (LA6_0==65) ) { |
| alt6=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 6, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt6) { |
| case 1 : |
| // InternalGridSource.g:1169:2: ( ruleJvmTypeReference ) |
| { |
| // InternalGridSource.g:1169:2: ( ruleJvmTypeReference ) |
| // InternalGridSource.g:1170:3: ruleJvmTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalGridSource.g:1175:2: ( ruleJvmWildcardTypeReference ) |
| { |
| // InternalGridSource.g:1175:2: ( ruleJvmWildcardTypeReference ) |
| // InternalGridSource.g:1176:3: ruleJvmWildcardTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmWildcardTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmArgumentTypeReference__Alternatives" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Alternatives_2" |
| // InternalGridSource.g:1185:1: rule__JvmWildcardTypeReference__Alternatives_2 : ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) ); |
| public final void rule__JvmWildcardTypeReference__Alternatives_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1189:1: ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) ) |
| int alt7=2; |
| int LA7_0 = input.LA(1); |
| |
| if ( (LA7_0==66) ) { |
| alt7=1; |
| } |
| else if ( (LA7_0==68) ) { |
| alt7=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 7, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt7) { |
| case 1 : |
| // InternalGridSource.g:1190:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) |
| { |
| // InternalGridSource.g:1190:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) |
| // InternalGridSource.g:1191:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); |
| } |
| // InternalGridSource.g:1192:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 ) |
| // InternalGridSource.g:1192:4: rule__JvmWildcardTypeReference__Group_2_0__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__Group_2_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalGridSource.g:1196:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) |
| { |
| // InternalGridSource.g:1196:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) |
| // InternalGridSource.g:1197:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); |
| } |
| // InternalGridSource.g:1198:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 ) |
| // InternalGridSource.g:1198:4: rule__JvmWildcardTypeReference__Group_2_1__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__Group_2_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__Alternatives_2" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Alternatives_1" |
| // InternalGridSource.g:1206:1: rule__XImportDeclaration__Alternatives_1 : ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) ); |
| public final void rule__XImportDeclaration__Alternatives_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1210:1: ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) ) |
| int alt8=3; |
| alt8 = dfa8.predict(input); |
| switch (alt8) { |
| case 1 : |
| // InternalGridSource.g:1211:2: ( ( rule__XImportDeclaration__Group_1_0__0 ) ) |
| { |
| // InternalGridSource.g:1211:2: ( ( rule__XImportDeclaration__Group_1_0__0 ) ) |
| // InternalGridSource.g:1212:3: ( rule__XImportDeclaration__Group_1_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); |
| } |
| // InternalGridSource.g:1213:3: ( rule__XImportDeclaration__Group_1_0__0 ) |
| // InternalGridSource.g:1213:4: rule__XImportDeclaration__Group_1_0__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__Group_1_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalGridSource.g:1217:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) |
| { |
| // InternalGridSource.g:1217:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) |
| // InternalGridSource.g:1218:3: ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); |
| } |
| // InternalGridSource.g:1219:3: ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) |
| // InternalGridSource.g:1219:4: rule__XImportDeclaration__ImportedTypeAssignment_1_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__ImportedTypeAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalGridSource.g:1223:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) |
| { |
| // InternalGridSource.g:1223:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) |
| // InternalGridSource.g:1224:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); |
| } |
| // InternalGridSource.g:1225:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) |
| // InternalGridSource.g:1225:4: rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__ImportedNamespaceAssignment_1_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Alternatives_1" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Alternatives_1_0_3" |
| // InternalGridSource.g:1233:1: rule__XImportDeclaration__Alternatives_1_0_3 : ( ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) ); |
| public final void rule__XImportDeclaration__Alternatives_1_0_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1237:1: ( ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) ) |
| int alt9=2; |
| int LA9_0 = input.LA(1); |
| |
| if ( (LA9_0==69) ) { |
| alt9=1; |
| } |
| else if ( (LA9_0==RULE_ID) ) { |
| alt9=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 9, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt9) { |
| case 1 : |
| // InternalGridSource.g:1238:2: ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) |
| { |
| // InternalGridSource.g:1238:2: ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) |
| // InternalGridSource.g:1239:3: ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); |
| } |
| // InternalGridSource.g:1240:3: ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) |
| // InternalGridSource.g:1240:4: rule__XImportDeclaration__WildcardAssignment_1_0_3_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__WildcardAssignment_1_0_3_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalGridSource.g:1244:2: ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) |
| { |
| // InternalGridSource.g:1244:2: ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) |
| // InternalGridSource.g:1245:3: ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); |
| } |
| // InternalGridSource.g:1246:3: ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) |
| // InternalGridSource.g:1246:4: rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__MemberNameAssignment_1_0_3_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Alternatives_1_0_3" |
| |
| |
| // $ANTLR start "rule__StyleCompare__Alternatives" |
| // InternalGridSource.g:1254:1: rule__StyleCompare__Alternatives : ( ( ( 'equal' ) ) | ( ( 'greater equal' ) ) | ( ( 'greater than' ) ) | ( ( 'lower equal' ) ) | ( ( 'lower than' ) ) | ( ( 'not equal' ) ) ); |
| public final void rule__StyleCompare__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1258:1: ( ( ( 'equal' ) ) | ( ( 'greater equal' ) ) | ( ( 'greater than' ) ) | ( ( 'lower equal' ) ) | ( ( 'lower than' ) ) | ( ( 'not equal' ) ) ) |
| int alt10=6; |
| switch ( input.LA(1) ) { |
| case 15: |
| { |
| alt10=1; |
| } |
| break; |
| case 16: |
| { |
| alt10=2; |
| } |
| break; |
| case 17: |
| { |
| alt10=3; |
| } |
| break; |
| case 18: |
| { |
| alt10=4; |
| } |
| break; |
| case 19: |
| { |
| alt10=5; |
| } |
| break; |
| case 20: |
| { |
| alt10=6; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 10, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt10) { |
| case 1 : |
| // InternalGridSource.g:1259:2: ( ( 'equal' ) ) |
| { |
| // InternalGridSource.g:1259:2: ( ( 'equal' ) ) |
| // InternalGridSource.g:1260:3: ( 'equal' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStyleCompareAccess().getEqualEnumLiteralDeclaration_0()); |
| } |
| // InternalGridSource.g:1261:3: ( 'equal' ) |
| // InternalGridSource.g:1261:4: 'equal' |
| { |
| match(input,15,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStyleCompareAccess().getEqualEnumLiteralDeclaration_0()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalGridSource.g:1265:2: ( ( 'greater equal' ) ) |
| { |
| // InternalGridSource.g:1265:2: ( ( 'greater equal' ) ) |
| // InternalGridSource.g:1266:3: ( 'greater equal' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStyleCompareAccess().getGreaterEqualEnumLiteralDeclaration_1()); |
| } |
| // InternalGridSource.g:1267:3: ( 'greater equal' ) |
| // InternalGridSource.g:1267:4: 'greater equal' |
| { |
| match(input,16,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStyleCompareAccess().getGreaterEqualEnumLiteralDeclaration_1()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalGridSource.g:1271:2: ( ( 'greater than' ) ) |
| { |
| // InternalGridSource.g:1271:2: ( ( 'greater than' ) ) |
| // InternalGridSource.g:1272:3: ( 'greater than' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStyleCompareAccess().getGreaterThanEnumLiteralDeclaration_2()); |
| } |
| // InternalGridSource.g:1273:3: ( 'greater than' ) |
| // InternalGridSource.g:1273:4: 'greater than' |
| { |
| match(input,17,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStyleCompareAccess().getGreaterThanEnumLiteralDeclaration_2()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalGridSource.g:1277:2: ( ( 'lower equal' ) ) |
| { |
| // InternalGridSource.g:1277:2: ( ( 'lower equal' ) ) |
| // InternalGridSource.g:1278:3: ( 'lower equal' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStyleCompareAccess().getLowerEqualEnumLiteralDeclaration_3()); |
| } |
| // InternalGridSource.g:1279:3: ( 'lower equal' ) |
| // InternalGridSource.g:1279:4: 'lower equal' |
| { |
| match(input,18,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStyleCompareAccess().getLowerEqualEnumLiteralDeclaration_3()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalGridSource.g:1283:2: ( ( 'lower than' ) ) |
| { |
| // InternalGridSource.g:1283:2: ( ( 'lower than' ) ) |
| // InternalGridSource.g:1284:3: ( 'lower than' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStyleCompareAccess().getLowerThanEnumLiteralDeclaration_4()); |
| } |
| // InternalGridSource.g:1285:3: ( 'lower than' ) |
| // InternalGridSource.g:1285:4: 'lower than' |
| { |
| match(input,19,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStyleCompareAccess().getLowerThanEnumLiteralDeclaration_4()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| case 6 : |
| // InternalGridSource.g:1289:2: ( ( 'not equal' ) ) |
| { |
| // InternalGridSource.g:1289:2: ( ( 'not equal' ) ) |
| // InternalGridSource.g:1290:3: ( 'not equal' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStyleCompareAccess().getNotEqualEnumLiteralDeclaration_5()); |
| } |
| // InternalGridSource.g:1291:3: ( 'not equal' ) |
| // InternalGridSource.g:1291:4: 'not equal' |
| { |
| match(input,20,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStyleCompareAccess().getNotEqualEnumLiteralDeclaration_5()); |
| } |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StyleCompare__Alternatives" |
| |
| |
| // $ANTLR start "rule__Source__Group__0" |
| // InternalGridSource.g:1299:1: rule__Source__Group__0 : rule__Source__Group__0__Impl rule__Source__Group__1 ; |
| public final void rule__Source__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1303:1: ( rule__Source__Group__0__Impl rule__Source__Group__1 ) |
| // InternalGridSource.g:1304:2: rule__Source__Group__0__Impl rule__Source__Group__1 |
| { |
| pushFollow(FOLLOW_4); |
| rule__Source__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__0" |
| |
| |
| // $ANTLR start "rule__Source__Group__0__Impl" |
| // InternalGridSource.g:1311:1: rule__Source__Group__0__Impl : ( 'gridsource' ) ; |
| public final void rule__Source__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1315:1: ( ( 'gridsource' ) ) |
| // InternalGridSource.g:1316:1: ( 'gridsource' ) |
| { |
| // InternalGridSource.g:1316:1: ( 'gridsource' ) |
| // InternalGridSource.g:1317:2: 'gridsource' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getGridsourceKeyword_0()); |
| } |
| match(input,21,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getGridsourceKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__Source__Group__1" |
| // InternalGridSource.g:1326:1: rule__Source__Group__1 : rule__Source__Group__1__Impl rule__Source__Group__2 ; |
| public final void rule__Source__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1330:1: ( rule__Source__Group__1__Impl rule__Source__Group__2 ) |
| // InternalGridSource.g:1331:2: rule__Source__Group__1__Impl rule__Source__Group__2 |
| { |
| pushFollow(FOLLOW_5); |
| rule__Source__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__1" |
| |
| |
| // $ANTLR start "rule__Source__Group__1__Impl" |
| // InternalGridSource.g:1338:1: rule__Source__Group__1__Impl : ( ( rule__Source__IdAssignment_1 ) ) ; |
| public final void rule__Source__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1342:1: ( ( ( rule__Source__IdAssignment_1 ) ) ) |
| // InternalGridSource.g:1343:1: ( ( rule__Source__IdAssignment_1 ) ) |
| { |
| // InternalGridSource.g:1343:1: ( ( rule__Source__IdAssignment_1 ) ) |
| // InternalGridSource.g:1344:2: ( rule__Source__IdAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getIdAssignment_1()); |
| } |
| // InternalGridSource.g:1345:2: ( rule__Source__IdAssignment_1 ) |
| // InternalGridSource.g:1345:3: rule__Source__IdAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Source__IdAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getIdAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Source__Group__2" |
| // InternalGridSource.g:1353:1: rule__Source__Group__2 : rule__Source__Group__2__Impl rule__Source__Group__3 ; |
| public final void rule__Source__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1357:1: ( rule__Source__Group__2__Impl rule__Source__Group__3 ) |
| // InternalGridSource.g:1358:2: rule__Source__Group__2__Impl rule__Source__Group__3 |
| { |
| pushFollow(FOLLOW_6); |
| rule__Source__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__2" |
| |
| |
| // $ANTLR start "rule__Source__Group__2__Impl" |
| // InternalGridSource.g:1365:1: rule__Source__Group__2__Impl : ( 'for' ) ; |
| public final void rule__Source__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1369:1: ( ( 'for' ) ) |
| // InternalGridSource.g:1370:1: ( 'for' ) |
| { |
| // InternalGridSource.g:1370:1: ( 'for' ) |
| // InternalGridSource.g:1371:2: 'for' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getForKeyword_2()); |
| } |
| match(input,22,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getForKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__Source__Group__3" |
| // InternalGridSource.g:1380:1: rule__Source__Group__3 : rule__Source__Group__3__Impl rule__Source__Group__4 ; |
| public final void rule__Source__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1384:1: ( rule__Source__Group__3__Impl rule__Source__Group__4 ) |
| // InternalGridSource.g:1385:2: rule__Source__Group__3__Impl rule__Source__Group__4 |
| { |
| pushFollow(FOLLOW_7); |
| rule__Source__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__3" |
| |
| |
| // $ANTLR start "rule__Source__Group__3__Impl" |
| // InternalGridSource.g:1392:1: rule__Source__Group__3__Impl : ( ( rule__Source__RootTypeAssignment_3 ) ) ; |
| public final void rule__Source__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1396:1: ( ( ( rule__Source__RootTypeAssignment_3 ) ) ) |
| // InternalGridSource.g:1397:1: ( ( rule__Source__RootTypeAssignment_3 ) ) |
| { |
| // InternalGridSource.g:1397:1: ( ( rule__Source__RootTypeAssignment_3 ) ) |
| // InternalGridSource.g:1398:2: ( rule__Source__RootTypeAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getRootTypeAssignment_3()); |
| } |
| // InternalGridSource.g:1399:2: ( rule__Source__RootTypeAssignment_3 ) |
| // InternalGridSource.g:1399:3: rule__Source__RootTypeAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Source__RootTypeAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getRootTypeAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__Source__Group__4" |
| // InternalGridSource.g:1407:1: rule__Source__Group__4 : rule__Source__Group__4__Impl rule__Source__Group__5 ; |
| public final void rule__Source__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1411:1: ( rule__Source__Group__4__Impl rule__Source__Group__5 ) |
| // InternalGridSource.g:1412:2: rule__Source__Group__4__Impl rule__Source__Group__5 |
| { |
| pushFollow(FOLLOW_8); |
| rule__Source__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__4" |
| |
| |
| // $ANTLR start "rule__Source__Group__4__Impl" |
| // InternalGridSource.g:1419:1: rule__Source__Group__4__Impl : ( '{' ) ; |
| public final void rule__Source__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1423:1: ( ( '{' ) ) |
| // InternalGridSource.g:1424:1: ( '{' ) |
| { |
| // InternalGridSource.g:1424:1: ( '{' ) |
| // InternalGridSource.g:1425:2: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getLeftCurlyBracketKeyword_4()); |
| } |
| match(input,23,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getLeftCurlyBracketKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__Source__Group__5" |
| // InternalGridSource.g:1434:1: rule__Source__Group__5 : rule__Source__Group__5__Impl rule__Source__Group__6 ; |
| public final void rule__Source__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1438:1: ( rule__Source__Group__5__Impl rule__Source__Group__6 ) |
| // InternalGridSource.g:1439:2: rule__Source__Group__5__Impl rule__Source__Group__6 |
| { |
| pushFollow(FOLLOW_7); |
| rule__Source__Group__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__6(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__5" |
| |
| |
| // $ANTLR start "rule__Source__Group__5__Impl" |
| // InternalGridSource.g:1446:1: rule__Source__Group__5__Impl : ( 'inputs' ) ; |
| public final void rule__Source__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1450:1: ( ( 'inputs' ) ) |
| // InternalGridSource.g:1451:1: ( 'inputs' ) |
| { |
| // InternalGridSource.g:1451:1: ( 'inputs' ) |
| // InternalGridSource.g:1452:2: 'inputs' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getInputsKeyword_5()); |
| } |
| match(input,24,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getInputsKeyword_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__Source__Group__6" |
| // InternalGridSource.g:1461:1: rule__Source__Group__6 : rule__Source__Group__6__Impl rule__Source__Group__7 ; |
| public final void rule__Source__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1465:1: ( rule__Source__Group__6__Impl rule__Source__Group__7 ) |
| // InternalGridSource.g:1466:2: rule__Source__Group__6__Impl rule__Source__Group__7 |
| { |
| pushFollow(FOLLOW_9); |
| rule__Source__Group__6__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__7(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__6" |
| |
| |
| // $ANTLR start "rule__Source__Group__6__Impl" |
| // InternalGridSource.g:1473:1: rule__Source__Group__6__Impl : ( '{' ) ; |
| public final void rule__Source__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1477:1: ( ( '{' ) ) |
| // InternalGridSource.g:1478:1: ( '{' ) |
| { |
| // InternalGridSource.g:1478:1: ( '{' ) |
| // InternalGridSource.g:1479:2: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getLeftCurlyBracketKeyword_6()); |
| } |
| match(input,23,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getLeftCurlyBracketKeyword_6()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__Source__Group__7" |
| // InternalGridSource.g:1488:1: rule__Source__Group__7 : rule__Source__Group__7__Impl rule__Source__Group__8 ; |
| public final void rule__Source__Group__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1492:1: ( rule__Source__Group__7__Impl rule__Source__Group__8 ) |
| // InternalGridSource.g:1493:2: rule__Source__Group__7__Impl rule__Source__Group__8 |
| { |
| pushFollow(FOLLOW_9); |
| rule__Source__Group__7__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__8(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__7" |
| |
| |
| // $ANTLR start "rule__Source__Group__7__Impl" |
| // InternalGridSource.g:1500:1: rule__Source__Group__7__Impl : ( ( rule__Source__InputsAssignment_7 )* ) ; |
| public final void rule__Source__Group__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1504:1: ( ( ( rule__Source__InputsAssignment_7 )* ) ) |
| // InternalGridSource.g:1505:1: ( ( rule__Source__InputsAssignment_7 )* ) |
| { |
| // InternalGridSource.g:1505:1: ( ( rule__Source__InputsAssignment_7 )* ) |
| // InternalGridSource.g:1506:2: ( rule__Source__InputsAssignment_7 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getInputsAssignment_7()); |
| } |
| // InternalGridSource.g:1507:2: ( rule__Source__InputsAssignment_7 )* |
| loop11: |
| do { |
| int alt11=2; |
| int LA11_0 = input.LA(1); |
| |
| if ( (LA11_0==26) ) { |
| alt11=1; |
| } |
| |
| |
| switch (alt11) { |
| case 1 : |
| // InternalGridSource.g:1507:3: rule__Source__InputsAssignment_7 |
| { |
| pushFollow(FOLLOW_10); |
| rule__Source__InputsAssignment_7(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop11; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getInputsAssignment_7()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__7__Impl" |
| |
| |
| // $ANTLR start "rule__Source__Group__8" |
| // InternalGridSource.g:1515:1: rule__Source__Group__8 : rule__Source__Group__8__Impl rule__Source__Group__9 ; |
| public final void rule__Source__Group__8() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1519:1: ( rule__Source__Group__8__Impl rule__Source__Group__9 ) |
| // InternalGridSource.g:1520:2: rule__Source__Group__8__Impl rule__Source__Group__9 |
| { |
| pushFollow(FOLLOW_11); |
| rule__Source__Group__8__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__9(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__8" |
| |
| |
| // $ANTLR start "rule__Source__Group__8__Impl" |
| // InternalGridSource.g:1527:1: rule__Source__Group__8__Impl : ( '}' ) ; |
| public final void rule__Source__Group__8__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1531:1: ( ( '}' ) ) |
| // InternalGridSource.g:1532:1: ( '}' ) |
| { |
| // InternalGridSource.g:1532:1: ( '}' ) |
| // InternalGridSource.g:1533:2: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getRightCurlyBracketKeyword_8()); |
| } |
| match(input,25,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getRightCurlyBracketKeyword_8()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__8__Impl" |
| |
| |
| // $ANTLR start "rule__Source__Group__9" |
| // InternalGridSource.g:1542:1: rule__Source__Group__9 : rule__Source__Group__9__Impl rule__Source__Group__10 ; |
| public final void rule__Source__Group__9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1546:1: ( rule__Source__Group__9__Impl rule__Source__Group__10 ) |
| // InternalGridSource.g:1547:2: rule__Source__Group__9__Impl rule__Source__Group__10 |
| { |
| pushFollow(FOLLOW_11); |
| rule__Source__Group__9__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__10(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__9" |
| |
| |
| // $ANTLR start "rule__Source__Group__9__Impl" |
| // InternalGridSource.g:1554:1: rule__Source__Group__9__Impl : ( ( rule__Source__PropertiesAssignment_9 )* ) ; |
| public final void rule__Source__Group__9__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1558:1: ( ( ( rule__Source__PropertiesAssignment_9 )* ) ) |
| // InternalGridSource.g:1559:1: ( ( rule__Source__PropertiesAssignment_9 )* ) |
| { |
| // InternalGridSource.g:1559:1: ( ( rule__Source__PropertiesAssignment_9 )* ) |
| // InternalGridSource.g:1560:2: ( rule__Source__PropertiesAssignment_9 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getPropertiesAssignment_9()); |
| } |
| // InternalGridSource.g:1561:2: ( rule__Source__PropertiesAssignment_9 )* |
| loop12: |
| do { |
| int alt12=2; |
| int LA12_0 = input.LA(1); |
| |
| if ( (LA12_0==32) ) { |
| alt12=1; |
| } |
| |
| |
| switch (alt12) { |
| case 1 : |
| // InternalGridSource.g:1561:3: rule__Source__PropertiesAssignment_9 |
| { |
| pushFollow(FOLLOW_12); |
| rule__Source__PropertiesAssignment_9(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop12; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getPropertiesAssignment_9()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__9__Impl" |
| |
| |
| // $ANTLR start "rule__Source__Group__10" |
| // InternalGridSource.g:1569:1: rule__Source__Group__10 : rule__Source__Group__10__Impl ; |
| public final void rule__Source__Group__10() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1573:1: ( rule__Source__Group__10__Impl ) |
| // InternalGridSource.g:1574:2: rule__Source__Group__10__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__Source__Group__10__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__10" |
| |
| |
| // $ANTLR start "rule__Source__Group__10__Impl" |
| // InternalGridSource.g:1580:1: rule__Source__Group__10__Impl : ( '}' ) ; |
| public final void rule__Source__Group__10__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1584:1: ( ( '}' ) ) |
| // InternalGridSource.g:1585:1: ( '}' ) |
| { |
| // InternalGridSource.g:1585:1: ( '}' ) |
| // InternalGridSource.g:1586:2: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getRightCurlyBracketKeyword_10()); |
| } |
| match(input,25,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getRightCurlyBracketKeyword_10()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__Group__10__Impl" |
| |
| |
| // $ANTLR start "rule__Input__Group__0" |
| // InternalGridSource.g:1596:1: rule__Input__Group__0 : rule__Input__Group__0__Impl rule__Input__Group__1 ; |
| public final void rule__Input__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1600:1: ( rule__Input__Group__0__Impl rule__Input__Group__1 ) |
| // InternalGridSource.g:1601:2: rule__Input__Group__0__Impl rule__Input__Group__1 |
| { |
| pushFollow(FOLLOW_6); |
| rule__Input__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Input__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group__0" |
| |
| |
| // $ANTLR start "rule__Input__Group__0__Impl" |
| // InternalGridSource.g:1608:1: rule__Input__Group__0__Impl : ( 'inputType' ) ; |
| public final void rule__Input__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1612:1: ( ( 'inputType' ) ) |
| // InternalGridSource.g:1613:1: ( 'inputType' ) |
| { |
| // InternalGridSource.g:1613:1: ( 'inputType' ) |
| // InternalGridSource.g:1614:2: 'inputType' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputAccess().getInputTypeKeyword_0()); |
| } |
| match(input,26,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputAccess().getInputTypeKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__Input__Group__1" |
| // InternalGridSource.g:1623:1: rule__Input__Group__1 : rule__Input__Group__1__Impl rule__Input__Group__2 ; |
| public final void rule__Input__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1627:1: ( rule__Input__Group__1__Impl rule__Input__Group__2 ) |
| // InternalGridSource.g:1628:2: rule__Input__Group__1__Impl rule__Input__Group__2 |
| { |
| pushFollow(FOLLOW_13); |
| rule__Input__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Input__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group__1" |
| |
| |
| // $ANTLR start "rule__Input__Group__1__Impl" |
| // InternalGridSource.g:1635:1: rule__Input__Group__1__Impl : ( ( rule__Input__InputTypeAssignment_1 ) ) ; |
| public final void rule__Input__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1639:1: ( ( ( rule__Input__InputTypeAssignment_1 ) ) ) |
| // InternalGridSource.g:1640:1: ( ( rule__Input__InputTypeAssignment_1 ) ) |
| { |
| // InternalGridSource.g:1640:1: ( ( rule__Input__InputTypeAssignment_1 ) ) |
| // InternalGridSource.g:1641:2: ( rule__Input__InputTypeAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputAccess().getInputTypeAssignment_1()); |
| } |
| // InternalGridSource.g:1642:2: ( rule__Input__InputTypeAssignment_1 ) |
| // InternalGridSource.g:1642:3: rule__Input__InputTypeAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Input__InputTypeAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputAccess().getInputTypeAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Input__Group__2" |
| // InternalGridSource.g:1650:1: rule__Input__Group__2 : rule__Input__Group__2__Impl rule__Input__Group__3 ; |
| public final void rule__Input__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1654:1: ( rule__Input__Group__2__Impl rule__Input__Group__3 ) |
| // InternalGridSource.g:1655:2: rule__Input__Group__2__Impl rule__Input__Group__3 |
| { |
| pushFollow(FOLLOW_14); |
| rule__Input__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Input__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group__2" |
| |
| |
| // $ANTLR start "rule__Input__Group__2__Impl" |
| // InternalGridSource.g:1662:1: rule__Input__Group__2__Impl : ( 'filters' ) ; |
| public final void rule__Input__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1666:1: ( ( 'filters' ) ) |
| // InternalGridSource.g:1667:1: ( 'filters' ) |
| { |
| // InternalGridSource.g:1667:1: ( 'filters' ) |
| // InternalGridSource.g:1668:2: 'filters' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputAccess().getFiltersKeyword_2()); |
| } |
| match(input,27,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputAccess().getFiltersKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__Input__Group__3" |
| // InternalGridSource.g:1677:1: rule__Input__Group__3 : rule__Input__Group__3__Impl rule__Input__Group__4 ; |
| public final void rule__Input__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1681:1: ( rule__Input__Group__3__Impl rule__Input__Group__4 ) |
| // InternalGridSource.g:1682:2: rule__Input__Group__3__Impl rule__Input__Group__4 |
| { |
| pushFollow(FOLLOW_15); |
| rule__Input__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Input__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group__3" |
| |
| |
| // $ANTLR start "rule__Input__Group__3__Impl" |
| // InternalGridSource.g:1689:1: rule__Input__Group__3__Impl : ( ( rule__Input__FiltersAssignment_3 ) ) ; |
| public final void rule__Input__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1693:1: ( ( ( rule__Input__FiltersAssignment_3 ) ) ) |
| // InternalGridSource.g:1694:1: ( ( rule__Input__FiltersAssignment_3 ) ) |
| { |
| // InternalGridSource.g:1694:1: ( ( rule__Input__FiltersAssignment_3 ) ) |
| // InternalGridSource.g:1695:2: ( rule__Input__FiltersAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputAccess().getFiltersAssignment_3()); |
| } |
| // InternalGridSource.g:1696:2: ( rule__Input__FiltersAssignment_3 ) |
| // InternalGridSource.g:1696:3: rule__Input__FiltersAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Input__FiltersAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputAccess().getFiltersAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__Input__Group__4" |
| // InternalGridSource.g:1704:1: rule__Input__Group__4 : rule__Input__Group__4__Impl ; |
| public final void rule__Input__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1708:1: ( rule__Input__Group__4__Impl ) |
| // InternalGridSource.g:1709:2: rule__Input__Group__4__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__Input__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group__4" |
| |
| |
| // $ANTLR start "rule__Input__Group__4__Impl" |
| // InternalGridSource.g:1715:1: rule__Input__Group__4__Impl : ( ( rule__Input__Group_4__0 )* ) ; |
| public final void rule__Input__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1719:1: ( ( ( rule__Input__Group_4__0 )* ) ) |
| // InternalGridSource.g:1720:1: ( ( rule__Input__Group_4__0 )* ) |
| { |
| // InternalGridSource.g:1720:1: ( ( rule__Input__Group_4__0 )* ) |
| // InternalGridSource.g:1721:2: ( rule__Input__Group_4__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputAccess().getGroup_4()); |
| } |
| // InternalGridSource.g:1722:2: ( rule__Input__Group_4__0 )* |
| loop13: |
| do { |
| int alt13=2; |
| int LA13_0 = input.LA(1); |
| |
| if ( (LA13_0==28) ) { |
| alt13=1; |
| } |
| |
| |
| switch (alt13) { |
| case 1 : |
| // InternalGridSource.g:1722:3: rule__Input__Group_4__0 |
| { |
| pushFollow(FOLLOW_16); |
| rule__Input__Group_4__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop13; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputAccess().getGroup_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__Input__Group_4__0" |
| // InternalGridSource.g:1731:1: rule__Input__Group_4__0 : rule__Input__Group_4__0__Impl rule__Input__Group_4__1 ; |
| public final void rule__Input__Group_4__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1735:1: ( rule__Input__Group_4__0__Impl rule__Input__Group_4__1 ) |
| // InternalGridSource.g:1736:2: rule__Input__Group_4__0__Impl rule__Input__Group_4__1 |
| { |
| pushFollow(FOLLOW_14); |
| rule__Input__Group_4__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Input__Group_4__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group_4__0" |
| |
| |
| // $ANTLR start "rule__Input__Group_4__0__Impl" |
| // InternalGridSource.g:1743:1: rule__Input__Group_4__0__Impl : ( '&&' ) ; |
| public final void rule__Input__Group_4__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1747:1: ( ( '&&' ) ) |
| // InternalGridSource.g:1748:1: ( '&&' ) |
| { |
| // InternalGridSource.g:1748:1: ( '&&' ) |
| // InternalGridSource.g:1749:2: '&&' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputAccess().getAmpersandAmpersandKeyword_4_0()); |
| } |
| match(input,28,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputAccess().getAmpersandAmpersandKeyword_4_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group_4__0__Impl" |
| |
| |
| // $ANTLR start "rule__Input__Group_4__1" |
| // InternalGridSource.g:1758:1: rule__Input__Group_4__1 : rule__Input__Group_4__1__Impl ; |
| public final void rule__Input__Group_4__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1762:1: ( rule__Input__Group_4__1__Impl ) |
| // InternalGridSource.g:1763:2: rule__Input__Group_4__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__Input__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__Input__Group_4__1" |
| |
| |
| // $ANTLR start "rule__Input__Group_4__1__Impl" |
| // InternalGridSource.g:1769:1: rule__Input__Group_4__1__Impl : ( ( rule__Input__FiltersAssignment_4_1 ) ) ; |
| public final void rule__Input__Group_4__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1773:1: ( ( ( rule__Input__FiltersAssignment_4_1 ) ) ) |
| // InternalGridSource.g:1774:1: ( ( rule__Input__FiltersAssignment_4_1 ) ) |
| { |
| // InternalGridSource.g:1774:1: ( ( rule__Input__FiltersAssignment_4_1 ) ) |
| // InternalGridSource.g:1775:2: ( rule__Input__FiltersAssignment_4_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputAccess().getFiltersAssignment_4_1()); |
| } |
| // InternalGridSource.g:1776:2: ( rule__Input__FiltersAssignment_4_1 ) |
| // InternalGridSource.g:1776:3: rule__Input__FiltersAssignment_4_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Input__FiltersAssignment_4_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputAccess().getFiltersAssignment_4_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__Group_4__1__Impl" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__0" |
| // InternalGridSource.g:1785:1: rule__EQFilter__Group__0 : rule__EQFilter__Group__0__Impl rule__EQFilter__Group__1 ; |
| public final void rule__EQFilter__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1789:1: ( rule__EQFilter__Group__0__Impl rule__EQFilter__Group__1 ) |
| // InternalGridSource.g:1790:2: rule__EQFilter__Group__0__Impl rule__EQFilter__Group__1 |
| { |
| pushFollow(FOLLOW_14); |
| rule__EQFilter__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__EQFilter__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__0" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__0__Impl" |
| // InternalGridSource.g:1797:1: rule__EQFilter__Group__0__Impl : ( () ) ; |
| public final void rule__EQFilter__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1801:1: ( ( () ) ) |
| // InternalGridSource.g:1802:1: ( () ) |
| { |
| // InternalGridSource.g:1802:1: ( () ) |
| // InternalGridSource.g:1803:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEQFilterAccess().getCxGridSourceEQFilterAction_0()); |
| } |
| // InternalGridSource.g:1804:2: () |
| // InternalGridSource.g:1804:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEQFilterAccess().getCxGridSourceEQFilterAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__1" |
| // InternalGridSource.g:1812:1: rule__EQFilter__Group__1 : rule__EQFilter__Group__1__Impl rule__EQFilter__Group__2 ; |
| public final void rule__EQFilter__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1816:1: ( rule__EQFilter__Group__1__Impl rule__EQFilter__Group__2 ) |
| // InternalGridSource.g:1817:2: rule__EQFilter__Group__1__Impl rule__EQFilter__Group__2 |
| { |
| pushFollow(FOLLOW_4); |
| rule__EQFilter__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__EQFilter__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__1" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__1__Impl" |
| // InternalGridSource.g:1824:1: rule__EQFilter__Group__1__Impl : ( 'root:' ) ; |
| public final void rule__EQFilter__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1828:1: ( ( 'root:' ) ) |
| // InternalGridSource.g:1829:1: ( 'root:' ) |
| { |
| // InternalGridSource.g:1829:1: ( 'root:' ) |
| // InternalGridSource.g:1830:2: 'root:' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEQFilterAccess().getRootKeyword_1()); |
| } |
| match(input,29,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEQFilterAccess().getRootKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__2" |
| // InternalGridSource.g:1839:1: rule__EQFilter__Group__2 : rule__EQFilter__Group__2__Impl rule__EQFilter__Group__3 ; |
| public final void rule__EQFilter__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1843:1: ( rule__EQFilter__Group__2__Impl rule__EQFilter__Group__3 ) |
| // InternalGridSource.g:1844:2: rule__EQFilter__Group__2__Impl rule__EQFilter__Group__3 |
| { |
| pushFollow(FOLLOW_17); |
| rule__EQFilter__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__EQFilter__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__2" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__2__Impl" |
| // InternalGridSource.g:1851:1: rule__EQFilter__Group__2__Impl : ( ( rule__EQFilter__RootTypePropertyPathAssignment_2 ) ) ; |
| public final void rule__EQFilter__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1855:1: ( ( ( rule__EQFilter__RootTypePropertyPathAssignment_2 ) ) ) |
| // InternalGridSource.g:1856:1: ( ( rule__EQFilter__RootTypePropertyPathAssignment_2 ) ) |
| { |
| // InternalGridSource.g:1856:1: ( ( rule__EQFilter__RootTypePropertyPathAssignment_2 ) ) |
| // InternalGridSource.g:1857:2: ( rule__EQFilter__RootTypePropertyPathAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEQFilterAccess().getRootTypePropertyPathAssignment_2()); |
| } |
| // InternalGridSource.g:1858:2: ( rule__EQFilter__RootTypePropertyPathAssignment_2 ) |
| // InternalGridSource.g:1858:3: rule__EQFilter__RootTypePropertyPathAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__EQFilter__RootTypePropertyPathAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEQFilterAccess().getRootTypePropertyPathAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__3" |
| // InternalGridSource.g:1866:1: rule__EQFilter__Group__3 : rule__EQFilter__Group__3__Impl rule__EQFilter__Group__4 ; |
| public final void rule__EQFilter__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1870:1: ( rule__EQFilter__Group__3__Impl rule__EQFilter__Group__4 ) |
| // InternalGridSource.g:1871:2: rule__EQFilter__Group__3__Impl rule__EQFilter__Group__4 |
| { |
| pushFollow(FOLLOW_18); |
| rule__EQFilter__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__EQFilter__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__3" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__3__Impl" |
| // InternalGridSource.g:1878:1: rule__EQFilter__Group__3__Impl : ( '=' ) ; |
| public final void rule__EQFilter__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1882:1: ( ( '=' ) ) |
| // InternalGridSource.g:1883:1: ( '=' ) |
| { |
| // InternalGridSource.g:1883:1: ( '=' ) |
| // InternalGridSource.g:1884:2: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEQFilterAccess().getEqualsSignKeyword_3()); |
| } |
| match(input,30,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEQFilterAccess().getEqualsSignKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__4" |
| // InternalGridSource.g:1893:1: rule__EQFilter__Group__4 : rule__EQFilter__Group__4__Impl rule__EQFilter__Group__5 ; |
| public final void rule__EQFilter__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1897:1: ( rule__EQFilter__Group__4__Impl rule__EQFilter__Group__5 ) |
| // InternalGridSource.g:1898:2: rule__EQFilter__Group__4__Impl rule__EQFilter__Group__5 |
| { |
| pushFollow(FOLLOW_4); |
| rule__EQFilter__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__EQFilter__Group__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__4" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__4__Impl" |
| // InternalGridSource.g:1905:1: rule__EQFilter__Group__4__Impl : ( 'input:' ) ; |
| public final void rule__EQFilter__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1909:1: ( ( 'input:' ) ) |
| // InternalGridSource.g:1910:1: ( 'input:' ) |
| { |
| // InternalGridSource.g:1910:1: ( 'input:' ) |
| // InternalGridSource.g:1911:2: 'input:' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEQFilterAccess().getInputKeyword_4()); |
| } |
| match(input,31,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEQFilterAccess().getInputKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__5" |
| // InternalGridSource.g:1920:1: rule__EQFilter__Group__5 : rule__EQFilter__Group__5__Impl ; |
| public final void rule__EQFilter__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1924:1: ( rule__EQFilter__Group__5__Impl ) |
| // InternalGridSource.g:1925:2: rule__EQFilter__Group__5__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__EQFilter__Group__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__5" |
| |
| |
| // $ANTLR start "rule__EQFilter__Group__5__Impl" |
| // InternalGridSource.g:1931:1: rule__EQFilter__Group__5__Impl : ( ( rule__EQFilter__InputTypePropertyPathAssignment_5 ) ) ; |
| public final void rule__EQFilter__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1935:1: ( ( ( rule__EQFilter__InputTypePropertyPathAssignment_5 ) ) ) |
| // InternalGridSource.g:1936:1: ( ( rule__EQFilter__InputTypePropertyPathAssignment_5 ) ) |
| { |
| // InternalGridSource.g:1936:1: ( ( rule__EQFilter__InputTypePropertyPathAssignment_5 ) ) |
| // InternalGridSource.g:1937:2: ( rule__EQFilter__InputTypePropertyPathAssignment_5 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEQFilterAccess().getInputTypePropertyPathAssignment_5()); |
| } |
| // InternalGridSource.g:1938:2: ( rule__EQFilter__InputTypePropertyPathAssignment_5 ) |
| // InternalGridSource.g:1938:3: rule__EQFilter__InputTypePropertyPathAssignment_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__EQFilter__InputTypePropertyPathAssignment_5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEQFilterAccess().getInputTypePropertyPathAssignment_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__Property__Group__0" |
| // InternalGridSource.g:1947:1: rule__Property__Group__0 : rule__Property__Group__0__Impl rule__Property__Group__1 ; |
| public final void rule__Property__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1951:1: ( rule__Property__Group__0__Impl rule__Property__Group__1 ) |
| // InternalGridSource.g:1952:2: rule__Property__Group__0__Impl rule__Property__Group__1 |
| { |
| pushFollow(FOLLOW_4); |
| rule__Property__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Property__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Property__Group__0" |
| |
| |
| // $ANTLR start "rule__Property__Group__0__Impl" |
| // InternalGridSource.g:1959:1: rule__Property__Group__0__Impl : ( 'prop' ) ; |
| public final void rule__Property__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1963:1: ( ( 'prop' ) ) |
| // InternalGridSource.g:1964:1: ( 'prop' ) |
| { |
| // InternalGridSource.g:1964:1: ( 'prop' ) |
| // InternalGridSource.g:1965:2: 'prop' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyAccess().getPropKeyword_0()); |
| } |
| match(input,32,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyAccess().getPropKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Property__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__Property__Group__1" |
| // InternalGridSource.g:1974:1: rule__Property__Group__1 : rule__Property__Group__1__Impl rule__Property__Group__2 ; |
| public final void rule__Property__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1978:1: ( rule__Property__Group__1__Impl rule__Property__Group__2 ) |
| // InternalGridSource.g:1979:2: rule__Property__Group__1__Impl rule__Property__Group__2 |
| { |
| pushFollow(FOLLOW_19); |
| rule__Property__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Property__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Property__Group__1" |
| |
| |
| // $ANTLR start "rule__Property__Group__1__Impl" |
| // InternalGridSource.g:1986:1: rule__Property__Group__1__Impl : ( ( rule__Property__PathAssignment_1 ) ) ; |
| public final void rule__Property__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:1990:1: ( ( ( rule__Property__PathAssignment_1 ) ) ) |
| // InternalGridSource.g:1991:1: ( ( rule__Property__PathAssignment_1 ) ) |
| { |
| // InternalGridSource.g:1991:1: ( ( rule__Property__PathAssignment_1 ) ) |
| // InternalGridSource.g:1992:2: ( rule__Property__PathAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyAccess().getPathAssignment_1()); |
| } |
| // InternalGridSource.g:1993:2: ( rule__Property__PathAssignment_1 ) |
| // InternalGridSource.g:1993:3: rule__Property__PathAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Property__PathAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyAccess().getPathAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Property__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Property__Group__2" |
| // InternalGridSource.g:2001:1: rule__Property__Group__2 : rule__Property__Group__2__Impl rule__Property__Group__3 ; |
| public final void rule__Property__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2005:1: ( rule__Property__Group__2__Impl rule__Property__Group__3 ) |
| // InternalGridSource.g:2006:2: rule__Property__Group__2__Impl rule__Property__Group__3 |
| { |
| pushFollow(FOLLOW_20); |
| rule__Property__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__Property__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Property__Group__2" |
| |
| |
| // $ANTLR start "rule__Property__Group__2__Impl" |
| // InternalGridSource.g:2013:1: rule__Property__Group__2__Impl : ( 'style' ) ; |
| public final void rule__Property__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2017:1: ( ( 'style' ) ) |
| // InternalGridSource.g:2018:1: ( 'style' ) |
| { |
| // InternalGridSource.g:2018:1: ( 'style' ) |
| // InternalGridSource.g:2019:2: 'style' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyAccess().getStyleKeyword_2()); |
| } |
| match(input,33,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyAccess().getStyleKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Property__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__Property__Group__3" |
| // InternalGridSource.g:2028:1: rule__Property__Group__3 : rule__Property__Group__3__Impl ; |
| public final void rule__Property__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2032:1: ( rule__Property__Group__3__Impl ) |
| // InternalGridSource.g:2033:2: rule__Property__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__Property__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Property__Group__3" |
| |
| |
| // $ANTLR start "rule__Property__Group__3__Impl" |
| // InternalGridSource.g:2039:1: rule__Property__Group__3__Impl : ( ( rule__Property__StyleAssignment_3 ) ) ; |
| public final void rule__Property__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2043:1: ( ( ( rule__Property__StyleAssignment_3 ) ) ) |
| // InternalGridSource.g:2044:1: ( ( rule__Property__StyleAssignment_3 ) ) |
| { |
| // InternalGridSource.g:2044:1: ( ( rule__Property__StyleAssignment_3 ) ) |
| // InternalGridSource.g:2045:2: ( rule__Property__StyleAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyAccess().getStyleAssignment_3()); |
| } |
| // InternalGridSource.g:2046:2: ( rule__Property__StyleAssignment_3 ) |
| // InternalGridSource.g:2046:3: rule__Property__StyleAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Property__StyleAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyAccess().getStyleAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Property__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__NestedField__Group__0" |
| // InternalGridSource.g:2055:1: rule__NestedField__Group__0 : rule__NestedField__Group__0__Impl rule__NestedField__Group__1 ; |
| public final void rule__NestedField__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2059:1: ( rule__NestedField__Group__0__Impl rule__NestedField__Group__1 ) |
| // InternalGridSource.g:2060:2: rule__NestedField__Group__0__Impl rule__NestedField__Group__1 |
| { |
| pushFollow(FOLLOW_4); |
| rule__NestedField__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__NestedField__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedField__Group__0" |
| |
| |
| // $ANTLR start "rule__NestedField__Group__0__Impl" |
| // InternalGridSource.g:2067:1: rule__NestedField__Group__0__Impl : ( () ) ; |
| public final void rule__NestedField__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2071:1: ( ( () ) ) |
| // InternalGridSource.g:2072:1: ( () ) |
| { |
| // InternalGridSource.g:2072:1: ( () ) |
| // InternalGridSource.g:2073:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedFieldAccess().getCxGridNestedFieldAction_0()); |
| } |
| // InternalGridSource.g:2074:2: () |
| // InternalGridSource.g:2074:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedFieldAccess().getCxGridNestedFieldAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedField__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__NestedField__Group__1" |
| // InternalGridSource.g:2082:1: rule__NestedField__Group__1 : rule__NestedField__Group__1__Impl rule__NestedField__Group__2 ; |
| public final void rule__NestedField__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2086:1: ( rule__NestedField__Group__1__Impl rule__NestedField__Group__2 ) |
| // InternalGridSource.g:2087:2: rule__NestedField__Group__1__Impl rule__NestedField__Group__2 |
| { |
| pushFollow(FOLLOW_21); |
| rule__NestedField__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__NestedField__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedField__Group__1" |
| |
| |
| // $ANTLR start "rule__NestedField__Group__1__Impl" |
| // InternalGridSource.g:2094:1: rule__NestedField__Group__1__Impl : ( ( rule__NestedField__FieldAssignment_1 ) ) ; |
| public final void rule__NestedField__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2098:1: ( ( ( rule__NestedField__FieldAssignment_1 ) ) ) |
| // InternalGridSource.g:2099:1: ( ( rule__NestedField__FieldAssignment_1 ) ) |
| { |
| // InternalGridSource.g:2099:1: ( ( rule__NestedField__FieldAssignment_1 ) ) |
| // InternalGridSource.g:2100:2: ( rule__NestedField__FieldAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedFieldAccess().getFieldAssignment_1()); |
| } |
| // InternalGridSource.g:2101:2: ( rule__NestedField__FieldAssignment_1 ) |
| // InternalGridSource.g:2101:3: rule__NestedField__FieldAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__NestedField__FieldAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedFieldAccess().getFieldAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedField__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__NestedField__Group__2" |
| // InternalGridSource.g:2109:1: rule__NestedField__Group__2 : rule__NestedField__Group__2__Impl ; |
| public final void rule__NestedField__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2113:1: ( rule__NestedField__Group__2__Impl ) |
| // InternalGridSource.g:2114:2: rule__NestedField__Group__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__NestedField__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedField__Group__2" |
| |
| |
| // $ANTLR start "rule__NestedField__Group__2__Impl" |
| // InternalGridSource.g:2120:1: rule__NestedField__Group__2__Impl : ( ( rule__NestedField__PathAssignment_2 )? ) ; |
| public final void rule__NestedField__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2124:1: ( ( ( rule__NestedField__PathAssignment_2 )? ) ) |
| // InternalGridSource.g:2125:1: ( ( rule__NestedField__PathAssignment_2 )? ) |
| { |
| // InternalGridSource.g:2125:1: ( ( rule__NestedField__PathAssignment_2 )? ) |
| // InternalGridSource.g:2126:2: ( rule__NestedField__PathAssignment_2 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedFieldAccess().getPathAssignment_2()); |
| } |
| // InternalGridSource.g:2127:2: ( rule__NestedField__PathAssignment_2 )? |
| int alt14=2; |
| int LA14_0 = input.LA(1); |
| |
| if ( (LA14_0==34) ) { |
| alt14=1; |
| } |
| switch (alt14) { |
| case 1 : |
| // InternalGridSource.g:2127:3: rule__NestedField__PathAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__NestedField__PathAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedFieldAccess().getPathAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedField__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__NestedPath__Group__0" |
| // InternalGridSource.g:2136:1: rule__NestedPath__Group__0 : rule__NestedPath__Group__0__Impl rule__NestedPath__Group__1 ; |
| public final void rule__NestedPath__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2140:1: ( rule__NestedPath__Group__0__Impl rule__NestedPath__Group__1 ) |
| // InternalGridSource.g:2141:2: rule__NestedPath__Group__0__Impl rule__NestedPath__Group__1 |
| { |
| pushFollow(FOLLOW_21); |
| rule__NestedPath__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__NestedPath__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedPath__Group__0" |
| |
| |
| // $ANTLR start "rule__NestedPath__Group__0__Impl" |
| // InternalGridSource.g:2148:1: rule__NestedPath__Group__0__Impl : ( () ) ; |
| public final void rule__NestedPath__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2152:1: ( ( () ) ) |
| // InternalGridSource.g:2153:1: ( () ) |
| { |
| // InternalGridSource.g:2153:1: ( () ) |
| // InternalGridSource.g:2154:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedPathAccess().getCxGridNestedPathAction_0()); |
| } |
| // InternalGridSource.g:2155:2: () |
| // InternalGridSource.g:2155:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedPathAccess().getCxGridNestedPathAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedPath__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__NestedPath__Group__1" |
| // InternalGridSource.g:2163:1: rule__NestedPath__Group__1 : rule__NestedPath__Group__1__Impl rule__NestedPath__Group__2 ; |
| public final void rule__NestedPath__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2167:1: ( rule__NestedPath__Group__1__Impl rule__NestedPath__Group__2 ) |
| // InternalGridSource.g:2168:2: rule__NestedPath__Group__1__Impl rule__NestedPath__Group__2 |
| { |
| pushFollow(FOLLOW_4); |
| rule__NestedPath__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__NestedPath__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedPath__Group__1" |
| |
| |
| // $ANTLR start "rule__NestedPath__Group__1__Impl" |
| // InternalGridSource.g:2175:1: rule__NestedPath__Group__1__Impl : ( '.' ) ; |
| public final void rule__NestedPath__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2179:1: ( ( '.' ) ) |
| // InternalGridSource.g:2180:1: ( '.' ) |
| { |
| // InternalGridSource.g:2180:1: ( '.' ) |
| // InternalGridSource.g:2181:2: '.' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedPathAccess().getFullStopKeyword_1()); |
| } |
| match(input,34,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedPathAccess().getFullStopKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedPath__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__NestedPath__Group__2" |
| // InternalGridSource.g:2190:1: rule__NestedPath__Group__2 : rule__NestedPath__Group__2__Impl rule__NestedPath__Group__3 ; |
| public final void rule__NestedPath__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2194:1: ( rule__NestedPath__Group__2__Impl rule__NestedPath__Group__3 ) |
| // InternalGridSource.g:2195:2: rule__NestedPath__Group__2__Impl rule__NestedPath__Group__3 |
| { |
| pushFollow(FOLLOW_21); |
| rule__NestedPath__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__NestedPath__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedPath__Group__2" |
| |
| |
| // $ANTLR start "rule__NestedPath__Group__2__Impl" |
| // InternalGridSource.g:2202:1: rule__NestedPath__Group__2__Impl : ( ( rule__NestedPath__FieldAssignment_2 ) ) ; |
| public final void rule__NestedPath__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2206:1: ( ( ( rule__NestedPath__FieldAssignment_2 ) ) ) |
| // InternalGridSource.g:2207:1: ( ( rule__NestedPath__FieldAssignment_2 ) ) |
| { |
| // InternalGridSource.g:2207:1: ( ( rule__NestedPath__FieldAssignment_2 ) ) |
| // InternalGridSource.g:2208:2: ( rule__NestedPath__FieldAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedPathAccess().getFieldAssignment_2()); |
| } |
| // InternalGridSource.g:2209:2: ( rule__NestedPath__FieldAssignment_2 ) |
| // InternalGridSource.g:2209:3: rule__NestedPath__FieldAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__NestedPath__FieldAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedPathAccess().getFieldAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedPath__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__NestedPath__Group__3" |
| // InternalGridSource.g:2217:1: rule__NestedPath__Group__3 : rule__NestedPath__Group__3__Impl ; |
| public final void rule__NestedPath__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2221:1: ( rule__NestedPath__Group__3__Impl ) |
| // InternalGridSource.g:2222:2: rule__NestedPath__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__NestedPath__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedPath__Group__3" |
| |
| |
| // $ANTLR start "rule__NestedPath__Group__3__Impl" |
| // InternalGridSource.g:2228:1: rule__NestedPath__Group__3__Impl : ( ( rule__NestedPath__PathAssignment_3 )? ) ; |
| public final void rule__NestedPath__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2232:1: ( ( ( rule__NestedPath__PathAssignment_3 )? ) ) |
| // InternalGridSource.g:2233:1: ( ( rule__NestedPath__PathAssignment_3 )? ) |
| { |
| // InternalGridSource.g:2233:1: ( ( rule__NestedPath__PathAssignment_3 )? ) |
| // InternalGridSource.g:2234:2: ( rule__NestedPath__PathAssignment_3 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedPathAccess().getPathAssignment_3()); |
| } |
| // InternalGridSource.g:2235:2: ( rule__NestedPath__PathAssignment_3 )? |
| int alt15=2; |
| int LA15_0 = input.LA(1); |
| |
| if ( (LA15_0==34) ) { |
| alt15=1; |
| } |
| switch (alt15) { |
| case 1 : |
| // InternalGridSource.g:2235:3: rule__NestedPath__PathAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__NestedPath__PathAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedPathAccess().getPathAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedPath__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyButtonStyle__Group__0" |
| // InternalGridSource.g:2244:1: rule__PropertyButtonStyle__Group__0 : rule__PropertyButtonStyle__Group__0__Impl rule__PropertyButtonStyle__Group__1 ; |
| public final void rule__PropertyButtonStyle__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2248:1: ( rule__PropertyButtonStyle__Group__0__Impl rule__PropertyButtonStyle__Group__1 ) |
| // InternalGridSource.g:2249:2: rule__PropertyButtonStyle__Group__0__Impl rule__PropertyButtonStyle__Group__1 |
| { |
| pushFollow(FOLLOW_22); |
| rule__PropertyButtonStyle__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyButtonStyle__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyButtonStyle__Group__0" |
| |
| |
| // $ANTLR start "rule__PropertyButtonStyle__Group__0__Impl" |
| // InternalGridSource.g:2256:1: rule__PropertyButtonStyle__Group__0__Impl : ( () ) ; |
| public final void rule__PropertyButtonStyle__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2260:1: ( ( () ) ) |
| // InternalGridSource.g:2261:1: ( () ) |
| { |
| // InternalGridSource.g:2261:1: ( () ) |
| // InternalGridSource.g:2262:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyButtonStyleAccess().getCxGridPropButtonStyleAction_0()); |
| } |
| // InternalGridSource.g:2263:2: () |
| // InternalGridSource.g:2263:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyButtonStyleAccess().getCxGridPropButtonStyleAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyButtonStyle__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyButtonStyle__Group__1" |
| // InternalGridSource.g:2271:1: rule__PropertyButtonStyle__Group__1 : rule__PropertyButtonStyle__Group__1__Impl rule__PropertyButtonStyle__Group__2 ; |
| public final void rule__PropertyButtonStyle__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2275:1: ( rule__PropertyButtonStyle__Group__1__Impl rule__PropertyButtonStyle__Group__2 ) |
| // InternalGridSource.g:2276:2: rule__PropertyButtonStyle__Group__1__Impl rule__PropertyButtonStyle__Group__2 |
| { |
| pushFollow(FOLLOW_23); |
| rule__PropertyButtonStyle__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyButtonStyle__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyButtonStyle__Group__1" |
| |
| |
| // $ANTLR start "rule__PropertyButtonStyle__Group__1__Impl" |
| // InternalGridSource.g:2283:1: rule__PropertyButtonStyle__Group__1__Impl : ( 'buttonStyle' ) ; |
| public final void rule__PropertyButtonStyle__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2287:1: ( ( 'buttonStyle' ) ) |
| // InternalGridSource.g:2288:1: ( 'buttonStyle' ) |
| { |
| // InternalGridSource.g:2288:1: ( 'buttonStyle' ) |
| // InternalGridSource.g:2289:2: 'buttonStyle' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyButtonStyleAccess().getButtonStyleKeyword_1()); |
| } |
| match(input,35,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyButtonStyleAccess().getButtonStyleKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyButtonStyle__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyButtonStyle__Group__2" |
| // InternalGridSource.g:2298:1: rule__PropertyButtonStyle__Group__2 : rule__PropertyButtonStyle__Group__2__Impl rule__PropertyButtonStyle__Group__3 ; |
| public final void rule__PropertyButtonStyle__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2302:1: ( rule__PropertyButtonStyle__Group__2__Impl rule__PropertyButtonStyle__Group__3 ) |
| // InternalGridSource.g:2303:2: rule__PropertyButtonStyle__Group__2__Impl rule__PropertyButtonStyle__Group__3 |
| { |
| pushFollow(FOLLOW_24); |
| rule__PropertyButtonStyle__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyButtonStyle__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyButtonStyle__Group__2" |
| |
| |
| // $ANTLR start "rule__PropertyButtonStyle__Group__2__Impl" |
| // InternalGridSource.g:2310:1: rule__PropertyButtonStyle__Group__2__Impl : ( 'eventTopic' ) ; |
| public final void rule__PropertyButtonStyle__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2314:1: ( ( 'eventTopic' ) ) |
| // InternalGridSource.g:2315:1: ( 'eventTopic' ) |
| { |
| // InternalGridSource.g:2315:1: ( 'eventTopic' ) |
| // InternalGridSource.g:2316:2: 'eventTopic' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyButtonStyleAccess().getEventTopicKeyword_2()); |
| } |
| match(input,36,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyButtonStyleAccess().getEventTopicKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyButtonStyle__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyButtonStyle__Group__3" |
| // InternalGridSource.g:2325:1: rule__PropertyButtonStyle__Group__3 : rule__PropertyButtonStyle__Group__3__Impl ; |
| public final void rule__PropertyButtonStyle__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2329:1: ( rule__PropertyButtonStyle__Group__3__Impl ) |
| // InternalGridSource.g:2330:2: rule__PropertyButtonStyle__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyButtonStyle__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyButtonStyle__Group__3" |
| |
| |
| // $ANTLR start "rule__PropertyButtonStyle__Group__3__Impl" |
| // InternalGridSource.g:2336:1: rule__PropertyButtonStyle__Group__3__Impl : ( ( rule__PropertyButtonStyle__EventTopicAssignment_3 ) ) ; |
| public final void rule__PropertyButtonStyle__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2340:1: ( ( ( rule__PropertyButtonStyle__EventTopicAssignment_3 ) ) ) |
| // InternalGridSource.g:2341:1: ( ( rule__PropertyButtonStyle__EventTopicAssignment_3 ) ) |
| { |
| // InternalGridSource.g:2341:1: ( ( rule__PropertyButtonStyle__EventTopicAssignment_3 ) ) |
| // InternalGridSource.g:2342:2: ( rule__PropertyButtonStyle__EventTopicAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyButtonStyleAccess().getEventTopicAssignment_3()); |
| } |
| // InternalGridSource.g:2343:2: ( rule__PropertyButtonStyle__EventTopicAssignment_3 ) |
| // InternalGridSource.g:2343:3: rule__PropertyButtonStyle__EventTopicAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyButtonStyle__EventTopicAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyButtonStyleAccess().getEventTopicAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyButtonStyle__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyHtmlStyle__Group__0" |
| // InternalGridSource.g:2352:1: rule__PropertyHtmlStyle__Group__0 : rule__PropertyHtmlStyle__Group__0__Impl rule__PropertyHtmlStyle__Group__1 ; |
| public final void rule__PropertyHtmlStyle__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2356:1: ( rule__PropertyHtmlStyle__Group__0__Impl rule__PropertyHtmlStyle__Group__1 ) |
| // InternalGridSource.g:2357:2: rule__PropertyHtmlStyle__Group__0__Impl rule__PropertyHtmlStyle__Group__1 |
| { |
| pushFollow(FOLLOW_25); |
| rule__PropertyHtmlStyle__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyHtmlStyle__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyHtmlStyle__Group__0" |
| |
| |
| // $ANTLR start "rule__PropertyHtmlStyle__Group__0__Impl" |
| // InternalGridSource.g:2364:1: rule__PropertyHtmlStyle__Group__0__Impl : ( () ) ; |
| public final void rule__PropertyHtmlStyle__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2368:1: ( ( () ) ) |
| // InternalGridSource.g:2369:1: ( () ) |
| { |
| // InternalGridSource.g:2369:1: ( () ) |
| // InternalGridSource.g:2370:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyHtmlStyleAccess().getCxGridPropHtmlStyleAction_0()); |
| } |
| // InternalGridSource.g:2371:2: () |
| // InternalGridSource.g:2371:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyHtmlStyleAccess().getCxGridPropHtmlStyleAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyHtmlStyle__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyHtmlStyle__Group__1" |
| // InternalGridSource.g:2379:1: rule__PropertyHtmlStyle__Group__1 : rule__PropertyHtmlStyle__Group__1__Impl ; |
| public final void rule__PropertyHtmlStyle__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2383:1: ( rule__PropertyHtmlStyle__Group__1__Impl ) |
| // InternalGridSource.g:2384:2: rule__PropertyHtmlStyle__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyHtmlStyle__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyHtmlStyle__Group__1" |
| |
| |
| // $ANTLR start "rule__PropertyHtmlStyle__Group__1__Impl" |
| // InternalGridSource.g:2390:1: rule__PropertyHtmlStyle__Group__1__Impl : ( 'htmlStyle' ) ; |
| public final void rule__PropertyHtmlStyle__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2394:1: ( ( 'htmlStyle' ) ) |
| // InternalGridSource.g:2395:1: ( 'htmlStyle' ) |
| { |
| // InternalGridSource.g:2395:1: ( 'htmlStyle' ) |
| // InternalGridSource.g:2396:2: 'htmlStyle' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyHtmlStyleAccess().getHtmlStyleKeyword_1()); |
| } |
| match(input,37,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyHtmlStyleAccess().getHtmlStyleKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyHtmlStyle__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyBooleanStyle__Group__0" |
| // InternalGridSource.g:2406:1: rule__PropertyBooleanStyle__Group__0 : rule__PropertyBooleanStyle__Group__0__Impl rule__PropertyBooleanStyle__Group__1 ; |
| public final void rule__PropertyBooleanStyle__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2410:1: ( rule__PropertyBooleanStyle__Group__0__Impl rule__PropertyBooleanStyle__Group__1 ) |
| // InternalGridSource.g:2411:2: rule__PropertyBooleanStyle__Group__0__Impl rule__PropertyBooleanStyle__Group__1 |
| { |
| pushFollow(FOLLOW_26); |
| rule__PropertyBooleanStyle__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyBooleanStyle__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyBooleanStyle__Group__0" |
| |
| |
| // $ANTLR start "rule__PropertyBooleanStyle__Group__0__Impl" |
| // InternalGridSource.g:2418:1: rule__PropertyBooleanStyle__Group__0__Impl : ( () ) ; |
| public final void rule__PropertyBooleanStyle__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2422:1: ( ( () ) ) |
| // InternalGridSource.g:2423:1: ( () ) |
| { |
| // InternalGridSource.g:2423:1: ( () ) |
| // InternalGridSource.g:2424:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyBooleanStyleAccess().getCxGridPropBooleanStyleAction_0()); |
| } |
| // InternalGridSource.g:2425:2: () |
| // InternalGridSource.g:2425:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyBooleanStyleAccess().getCxGridPropBooleanStyleAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyBooleanStyle__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyBooleanStyle__Group__1" |
| // InternalGridSource.g:2433:1: rule__PropertyBooleanStyle__Group__1 : rule__PropertyBooleanStyle__Group__1__Impl ; |
| public final void rule__PropertyBooleanStyle__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2437:1: ( rule__PropertyBooleanStyle__Group__1__Impl ) |
| // InternalGridSource.g:2438:2: rule__PropertyBooleanStyle__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyBooleanStyle__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyBooleanStyle__Group__1" |
| |
| |
| // $ANTLR start "rule__PropertyBooleanStyle__Group__1__Impl" |
| // InternalGridSource.g:2444:1: rule__PropertyBooleanStyle__Group__1__Impl : ( 'boolStyle' ) ; |
| public final void rule__PropertyBooleanStyle__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2448:1: ( ( 'boolStyle' ) ) |
| // InternalGridSource.g:2449:1: ( 'boolStyle' ) |
| { |
| // InternalGridSource.g:2449:1: ( 'boolStyle' ) |
| // InternalGridSource.g:2450:2: 'boolStyle' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyBooleanStyleAccess().getBoolStyleKeyword_1()); |
| } |
| match(input,38,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyBooleanStyleAccess().getBoolStyleKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyBooleanStyle__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyDateStyle__Group__0" |
| // InternalGridSource.g:2460:1: rule__PropertyDateStyle__Group__0 : rule__PropertyDateStyle__Group__0__Impl rule__PropertyDateStyle__Group__1 ; |
| public final void rule__PropertyDateStyle__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2464:1: ( rule__PropertyDateStyle__Group__0__Impl rule__PropertyDateStyle__Group__1 ) |
| // InternalGridSource.g:2465:2: rule__PropertyDateStyle__Group__0__Impl rule__PropertyDateStyle__Group__1 |
| { |
| pushFollow(FOLLOW_27); |
| rule__PropertyDateStyle__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyDateStyle__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyDateStyle__Group__0" |
| |
| |
| // $ANTLR start "rule__PropertyDateStyle__Group__0__Impl" |
| // InternalGridSource.g:2472:1: rule__PropertyDateStyle__Group__0__Impl : ( () ) ; |
| public final void rule__PropertyDateStyle__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2476:1: ( ( () ) ) |
| // InternalGridSource.g:2477:1: ( () ) |
| { |
| // InternalGridSource.g:2477:1: ( () ) |
| // InternalGridSource.g:2478:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyDateStyleAccess().getCxGridPropDateStyleAction_0()); |
| } |
| // InternalGridSource.g:2479:2: () |
| // InternalGridSource.g:2479:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyDateStyleAccess().getCxGridPropDateStyleAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyDateStyle__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyDateStyle__Group__1" |
| // InternalGridSource.g:2487:1: rule__PropertyDateStyle__Group__1 : rule__PropertyDateStyle__Group__1__Impl rule__PropertyDateStyle__Group__2 ; |
| public final void rule__PropertyDateStyle__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2491:1: ( rule__PropertyDateStyle__Group__1__Impl rule__PropertyDateStyle__Group__2 ) |
| // InternalGridSource.g:2492:2: rule__PropertyDateStyle__Group__1__Impl rule__PropertyDateStyle__Group__2 |
| { |
| pushFollow(FOLLOW_28); |
| rule__PropertyDateStyle__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyDateStyle__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyDateStyle__Group__1" |
| |
| |
| // $ANTLR start "rule__PropertyDateStyle__Group__1__Impl" |
| // InternalGridSource.g:2499:1: rule__PropertyDateStyle__Group__1__Impl : ( 'dateStyle' ) ; |
| public final void rule__PropertyDateStyle__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2503:1: ( ( 'dateStyle' ) ) |
| // InternalGridSource.g:2504:1: ( 'dateStyle' ) |
| { |
| // InternalGridSource.g:2504:1: ( 'dateStyle' ) |
| // InternalGridSource.g:2505:2: 'dateStyle' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyDateStyleAccess().getDateStyleKeyword_1()); |
| } |
| match(input,39,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyDateStyleAccess().getDateStyleKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyDateStyle__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyDateStyle__Group__2" |
| // InternalGridSource.g:2514:1: rule__PropertyDateStyle__Group__2 : rule__PropertyDateStyle__Group__2__Impl rule__PropertyDateStyle__Group__3 ; |
| public final void rule__PropertyDateStyle__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2518:1: ( rule__PropertyDateStyle__Group__2__Impl rule__PropertyDateStyle__Group__3 ) |
| // InternalGridSource.g:2519:2: rule__PropertyDateStyle__Group__2__Impl rule__PropertyDateStyle__Group__3 |
| { |
| pushFollow(FOLLOW_24); |
| rule__PropertyDateStyle__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyDateStyle__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyDateStyle__Group__2" |
| |
| |
| // $ANTLR start "rule__PropertyDateStyle__Group__2__Impl" |
| // InternalGridSource.g:2526:1: rule__PropertyDateStyle__Group__2__Impl : ( 'format' ) ; |
| public final void rule__PropertyDateStyle__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2530:1: ( ( 'format' ) ) |
| // InternalGridSource.g:2531:1: ( 'format' ) |
| { |
| // InternalGridSource.g:2531:1: ( 'format' ) |
| // InternalGridSource.g:2532:2: 'format' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyDateStyleAccess().getFormatKeyword_2()); |
| } |
| match(input,40,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyDateStyleAccess().getFormatKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyDateStyle__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyDateStyle__Group__3" |
| // InternalGridSource.g:2541:1: rule__PropertyDateStyle__Group__3 : rule__PropertyDateStyle__Group__3__Impl ; |
| public final void rule__PropertyDateStyle__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2545:1: ( rule__PropertyDateStyle__Group__3__Impl ) |
| // InternalGridSource.g:2546:2: rule__PropertyDateStyle__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyDateStyle__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyDateStyle__Group__3" |
| |
| |
| // $ANTLR start "rule__PropertyDateStyle__Group__3__Impl" |
| // InternalGridSource.g:2552:1: rule__PropertyDateStyle__Group__3__Impl : ( ( rule__PropertyDateStyle__DateFormatAssignment_3 ) ) ; |
| public final void rule__PropertyDateStyle__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2556:1: ( ( ( rule__PropertyDateStyle__DateFormatAssignment_3 ) ) ) |
| // InternalGridSource.g:2557:1: ( ( rule__PropertyDateStyle__DateFormatAssignment_3 ) ) |
| { |
| // InternalGridSource.g:2557:1: ( ( rule__PropertyDateStyle__DateFormatAssignment_3 ) ) |
| // InternalGridSource.g:2558:2: ( rule__PropertyDateStyle__DateFormatAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyDateStyleAccess().getDateFormatAssignment_3()); |
| } |
| // InternalGridSource.g:2559:2: ( rule__PropertyDateStyle__DateFormatAssignment_3 ) |
| // InternalGridSource.g:2559:3: rule__PropertyDateStyle__DateFormatAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyDateStyle__DateFormatAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyDateStyleAccess().getDateFormatAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyDateStyle__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyNumberStyle__Group__0" |
| // InternalGridSource.g:2568:1: rule__PropertyNumberStyle__Group__0 : rule__PropertyNumberStyle__Group__0__Impl rule__PropertyNumberStyle__Group__1 ; |
| public final void rule__PropertyNumberStyle__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2572:1: ( rule__PropertyNumberStyle__Group__0__Impl rule__PropertyNumberStyle__Group__1 ) |
| // InternalGridSource.g:2573:2: rule__PropertyNumberStyle__Group__0__Impl rule__PropertyNumberStyle__Group__1 |
| { |
| pushFollow(FOLLOW_29); |
| rule__PropertyNumberStyle__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyNumberStyle__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyNumberStyle__Group__0" |
| |
| |
| // $ANTLR start "rule__PropertyNumberStyle__Group__0__Impl" |
| // InternalGridSource.g:2580:1: rule__PropertyNumberStyle__Group__0__Impl : ( () ) ; |
| public final void rule__PropertyNumberStyle__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2584:1: ( ( () ) ) |
| // InternalGridSource.g:2585:1: ( () ) |
| { |
| // InternalGridSource.g:2585:1: ( () ) |
| // InternalGridSource.g:2586:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyNumberStyleAccess().getCxGridPropNumberStyleAction_0()); |
| } |
| // InternalGridSource.g:2587:2: () |
| // InternalGridSource.g:2587:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyNumberStyleAccess().getCxGridPropNumberStyleAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyNumberStyle__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyNumberStyle__Group__1" |
| // InternalGridSource.g:2595:1: rule__PropertyNumberStyle__Group__1 : rule__PropertyNumberStyle__Group__1__Impl rule__PropertyNumberStyle__Group__2 ; |
| public final void rule__PropertyNumberStyle__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2599:1: ( rule__PropertyNumberStyle__Group__1__Impl rule__PropertyNumberStyle__Group__2 ) |
| // InternalGridSource.g:2600:2: rule__PropertyNumberStyle__Group__1__Impl rule__PropertyNumberStyle__Group__2 |
| { |
| pushFollow(FOLLOW_28); |
| rule__PropertyNumberStyle__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyNumberStyle__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyNumberStyle__Group__1" |
| |
| |
| // $ANTLR start "rule__PropertyNumberStyle__Group__1__Impl" |
| // InternalGridSource.g:2607:1: rule__PropertyNumberStyle__Group__1__Impl : ( 'numberStyle' ) ; |
| public final void rule__PropertyNumberStyle__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2611:1: ( ( 'numberStyle' ) ) |
| // InternalGridSource.g:2612:1: ( 'numberStyle' ) |
| { |
| // InternalGridSource.g:2612:1: ( 'numberStyle' ) |
| // InternalGridSource.g:2613:2: 'numberStyle' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyNumberStyleAccess().getNumberStyleKeyword_1()); |
| } |
| match(input,41,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyNumberStyleAccess().getNumberStyleKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyNumberStyle__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyNumberStyle__Group__2" |
| // InternalGridSource.g:2622:1: rule__PropertyNumberStyle__Group__2 : rule__PropertyNumberStyle__Group__2__Impl rule__PropertyNumberStyle__Group__3 ; |
| public final void rule__PropertyNumberStyle__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2626:1: ( rule__PropertyNumberStyle__Group__2__Impl rule__PropertyNumberStyle__Group__3 ) |
| // InternalGridSource.g:2627:2: rule__PropertyNumberStyle__Group__2__Impl rule__PropertyNumberStyle__Group__3 |
| { |
| pushFollow(FOLLOW_24); |
| rule__PropertyNumberStyle__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyNumberStyle__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyNumberStyle__Group__2" |
| |
| |
| // $ANTLR start "rule__PropertyNumberStyle__Group__2__Impl" |
| // InternalGridSource.g:2634:1: rule__PropertyNumberStyle__Group__2__Impl : ( 'format' ) ; |
| public final void rule__PropertyNumberStyle__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2638:1: ( ( 'format' ) ) |
| // InternalGridSource.g:2639:1: ( 'format' ) |
| { |
| // InternalGridSource.g:2639:1: ( 'format' ) |
| // InternalGridSource.g:2640:2: 'format' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyNumberStyleAccess().getFormatKeyword_2()); |
| } |
| match(input,40,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyNumberStyleAccess().getFormatKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyNumberStyle__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyNumberStyle__Group__3" |
| // InternalGridSource.g:2649:1: rule__PropertyNumberStyle__Group__3 : rule__PropertyNumberStyle__Group__3__Impl ; |
| public final void rule__PropertyNumberStyle__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2653:1: ( rule__PropertyNumberStyle__Group__3__Impl ) |
| // InternalGridSource.g:2654:2: rule__PropertyNumberStyle__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyNumberStyle__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyNumberStyle__Group__3" |
| |
| |
| // $ANTLR start "rule__PropertyNumberStyle__Group__3__Impl" |
| // InternalGridSource.g:2660:1: rule__PropertyNumberStyle__Group__3__Impl : ( ( rule__PropertyNumberStyle__NumberFormatAssignment_3 ) ) ; |
| public final void rule__PropertyNumberStyle__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2664:1: ( ( ( rule__PropertyNumberStyle__NumberFormatAssignment_3 ) ) ) |
| // InternalGridSource.g:2665:1: ( ( rule__PropertyNumberStyle__NumberFormatAssignment_3 ) ) |
| { |
| // InternalGridSource.g:2665:1: ( ( rule__PropertyNumberStyle__NumberFormatAssignment_3 ) ) |
| // InternalGridSource.g:2666:2: ( rule__PropertyNumberStyle__NumberFormatAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyNumberStyleAccess().getNumberFormatAssignment_3()); |
| } |
| // InternalGridSource.g:2667:2: ( rule__PropertyNumberStyle__NumberFormatAssignment_3 ) |
| // InternalGridSource.g:2667:3: rule__PropertyNumberStyle__NumberFormatAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyNumberStyle__NumberFormatAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyNumberStyleAccess().getNumberFormatAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyNumberStyle__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyProgressbarStyle__Group__0" |
| // InternalGridSource.g:2676:1: rule__PropertyProgressbarStyle__Group__0 : rule__PropertyProgressbarStyle__Group__0__Impl rule__PropertyProgressbarStyle__Group__1 ; |
| public final void rule__PropertyProgressbarStyle__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2680:1: ( rule__PropertyProgressbarStyle__Group__0__Impl rule__PropertyProgressbarStyle__Group__1 ) |
| // InternalGridSource.g:2681:2: rule__PropertyProgressbarStyle__Group__0__Impl rule__PropertyProgressbarStyle__Group__1 |
| { |
| pushFollow(FOLLOW_30); |
| rule__PropertyProgressbarStyle__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyProgressbarStyle__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyProgressbarStyle__Group__0" |
| |
| |
| // $ANTLR start "rule__PropertyProgressbarStyle__Group__0__Impl" |
| // InternalGridSource.g:2688:1: rule__PropertyProgressbarStyle__Group__0__Impl : ( () ) ; |
| public final void rule__PropertyProgressbarStyle__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2692:1: ( ( () ) ) |
| // InternalGridSource.g:2693:1: ( () ) |
| { |
| // InternalGridSource.g:2693:1: ( () ) |
| // InternalGridSource.g:2694:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyProgressbarStyleAccess().getCxGridPropProgressbarStyleAction_0()); |
| } |
| // InternalGridSource.g:2695:2: () |
| // InternalGridSource.g:2695:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyProgressbarStyleAccess().getCxGridPropProgressbarStyleAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyProgressbarStyle__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyProgressbarStyle__Group__1" |
| // InternalGridSource.g:2703:1: rule__PropertyProgressbarStyle__Group__1 : rule__PropertyProgressbarStyle__Group__1__Impl rule__PropertyProgressbarStyle__Group__2 ; |
| public final void rule__PropertyProgressbarStyle__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2707:1: ( rule__PropertyProgressbarStyle__Group__1__Impl rule__PropertyProgressbarStyle__Group__2 ) |
| // InternalGridSource.g:2708:2: rule__PropertyProgressbarStyle__Group__1__Impl rule__PropertyProgressbarStyle__Group__2 |
| { |
| pushFollow(FOLLOW_31); |
| rule__PropertyProgressbarStyle__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyProgressbarStyle__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyProgressbarStyle__Group__1" |
| |
| |
| // $ANTLR start "rule__PropertyProgressbarStyle__Group__1__Impl" |
| // InternalGridSource.g:2715:1: rule__PropertyProgressbarStyle__Group__1__Impl : ( 'progressbarStyle' ) ; |
| public final void rule__PropertyProgressbarStyle__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2719:1: ( ( 'progressbarStyle' ) ) |
| // InternalGridSource.g:2720:1: ( 'progressbarStyle' ) |
| { |
| // InternalGridSource.g:2720:1: ( 'progressbarStyle' ) |
| // InternalGridSource.g:2721:2: 'progressbarStyle' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyProgressbarStyleAccess().getProgressbarStyleKeyword_1()); |
| } |
| match(input,42,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyProgressbarStyleAccess().getProgressbarStyleKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyProgressbarStyle__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyProgressbarStyle__Group__2" |
| // InternalGridSource.g:2730:1: rule__PropertyProgressbarStyle__Group__2 : rule__PropertyProgressbarStyle__Group__2__Impl rule__PropertyProgressbarStyle__Group__3 ; |
| public final void rule__PropertyProgressbarStyle__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2734:1: ( rule__PropertyProgressbarStyle__Group__2__Impl rule__PropertyProgressbarStyle__Group__3 ) |
| // InternalGridSource.g:2735:2: rule__PropertyProgressbarStyle__Group__2__Impl rule__PropertyProgressbarStyle__Group__3 |
| { |
| pushFollow(FOLLOW_32); |
| rule__PropertyProgressbarStyle__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyProgressbarStyle__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyProgressbarStyle__Group__2" |
| |
| |
| // $ANTLR start "rule__PropertyProgressbarStyle__Group__2__Impl" |
| // InternalGridSource.g:2742:1: rule__PropertyProgressbarStyle__Group__2__Impl : ( 'max' ) ; |
| public final void rule__PropertyProgressbarStyle__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2746:1: ( ( 'max' ) ) |
| // InternalGridSource.g:2747:1: ( 'max' ) |
| { |
| // InternalGridSource.g:2747:1: ( 'max' ) |
| // InternalGridSource.g:2748:2: 'max' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyProgressbarStyleAccess().getMaxKeyword_2()); |
| } |
| match(input,43,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyProgressbarStyleAccess().getMaxKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyProgressbarStyle__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyProgressbarStyle__Group__3" |
| // InternalGridSource.g:2757:1: rule__PropertyProgressbarStyle__Group__3 : rule__PropertyProgressbarStyle__Group__3__Impl ; |
| public final void rule__PropertyProgressbarStyle__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2761:1: ( rule__PropertyProgressbarStyle__Group__3__Impl ) |
| // InternalGridSource.g:2762:2: rule__PropertyProgressbarStyle__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyProgressbarStyle__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyProgressbarStyle__Group__3" |
| |
| |
| // $ANTLR start "rule__PropertyProgressbarStyle__Group__3__Impl" |
| // InternalGridSource.g:2768:1: rule__PropertyProgressbarStyle__Group__3__Impl : ( ( rule__PropertyProgressbarStyle__MaxValueAssignment_3 ) ) ; |
| public final void rule__PropertyProgressbarStyle__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2772:1: ( ( ( rule__PropertyProgressbarStyle__MaxValueAssignment_3 ) ) ) |
| // InternalGridSource.g:2773:1: ( ( rule__PropertyProgressbarStyle__MaxValueAssignment_3 ) ) |
| { |
| // InternalGridSource.g:2773:1: ( ( rule__PropertyProgressbarStyle__MaxValueAssignment_3 ) ) |
| // InternalGridSource.g:2774:2: ( rule__PropertyProgressbarStyle__MaxValueAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyProgressbarStyleAccess().getMaxValueAssignment_3()); |
| } |
| // InternalGridSource.g:2775:2: ( rule__PropertyProgressbarStyle__MaxValueAssignment_3 ) |
| // InternalGridSource.g:2775:3: rule__PropertyProgressbarStyle__MaxValueAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyProgressbarStyle__MaxValueAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyProgressbarStyleAccess().getMaxValueAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyProgressbarStyle__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__0" |
| // InternalGridSource.g:2784:1: rule__GridPropIndicatorStyle__Group__0 : rule__GridPropIndicatorStyle__Group__0__Impl rule__GridPropIndicatorStyle__Group__1 ; |
| public final void rule__GridPropIndicatorStyle__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2788:1: ( rule__GridPropIndicatorStyle__Group__0__Impl rule__GridPropIndicatorStyle__Group__1 ) |
| // InternalGridSource.g:2789:2: rule__GridPropIndicatorStyle__Group__0__Impl rule__GridPropIndicatorStyle__Group__1 |
| { |
| pushFollow(FOLLOW_20); |
| rule__GridPropIndicatorStyle__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__GridPropIndicatorStyle__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__0" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__0__Impl" |
| // InternalGridSource.g:2796:1: rule__GridPropIndicatorStyle__Group__0__Impl : ( () ) ; |
| public final void rule__GridPropIndicatorStyle__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2800:1: ( ( () ) ) |
| // InternalGridSource.g:2801:1: ( () ) |
| { |
| // InternalGridSource.g:2801:1: ( () ) |
| // InternalGridSource.g:2802:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getGridPropIndicatorStyleAccess().getCxGridPropIndicatorStyleAction_0()); |
| } |
| // InternalGridSource.g:2803:2: () |
| // InternalGridSource.g:2803:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getGridPropIndicatorStyleAccess().getCxGridPropIndicatorStyleAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__1" |
| // InternalGridSource.g:2811:1: rule__GridPropIndicatorStyle__Group__1 : rule__GridPropIndicatorStyle__Group__1__Impl rule__GridPropIndicatorStyle__Group__2 ; |
| public final void rule__GridPropIndicatorStyle__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2815:1: ( rule__GridPropIndicatorStyle__Group__1__Impl rule__GridPropIndicatorStyle__Group__2 ) |
| // InternalGridSource.g:2816:2: rule__GridPropIndicatorStyle__Group__1__Impl rule__GridPropIndicatorStyle__Group__2 |
| { |
| pushFollow(FOLLOW_33); |
| rule__GridPropIndicatorStyle__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__GridPropIndicatorStyle__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__1" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__1__Impl" |
| // InternalGridSource.g:2823:1: rule__GridPropIndicatorStyle__Group__1__Impl : ( 'indicatorStyle' ) ; |
| public final void rule__GridPropIndicatorStyle__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2827:1: ( ( 'indicatorStyle' ) ) |
| // InternalGridSource.g:2828:1: ( 'indicatorStyle' ) |
| { |
| // InternalGridSource.g:2828:1: ( 'indicatorStyle' ) |
| // InternalGridSource.g:2829:2: 'indicatorStyle' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getGridPropIndicatorStyleAccess().getIndicatorStyleKeyword_1()); |
| } |
| match(input,44,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getGridPropIndicatorStyleAccess().getIndicatorStyleKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__2" |
| // InternalGridSource.g:2838:1: rule__GridPropIndicatorStyle__Group__2 : rule__GridPropIndicatorStyle__Group__2__Impl rule__GridPropIndicatorStyle__Group__3 ; |
| public final void rule__GridPropIndicatorStyle__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2842:1: ( rule__GridPropIndicatorStyle__Group__2__Impl rule__GridPropIndicatorStyle__Group__3 ) |
| // InternalGridSource.g:2843:2: rule__GridPropIndicatorStyle__Group__2__Impl rule__GridPropIndicatorStyle__Group__3 |
| { |
| pushFollow(FOLLOW_32); |
| rule__GridPropIndicatorStyle__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__GridPropIndicatorStyle__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__2" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__2__Impl" |
| // InternalGridSource.g:2850:1: rule__GridPropIndicatorStyle__Group__2__Impl : ( 'greenFrom' ) ; |
| public final void rule__GridPropIndicatorStyle__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2854:1: ( ( 'greenFrom' ) ) |
| // InternalGridSource.g:2855:1: ( 'greenFrom' ) |
| { |
| // InternalGridSource.g:2855:1: ( 'greenFrom' ) |
| // InternalGridSource.g:2856:2: 'greenFrom' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getGridPropIndicatorStyleAccess().getGreenFromKeyword_2()); |
| } |
| match(input,45,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getGridPropIndicatorStyleAccess().getGreenFromKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__3" |
| // InternalGridSource.g:2865:1: rule__GridPropIndicatorStyle__Group__3 : rule__GridPropIndicatorStyle__Group__3__Impl rule__GridPropIndicatorStyle__Group__4 ; |
| public final void rule__GridPropIndicatorStyle__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2869:1: ( rule__GridPropIndicatorStyle__Group__3__Impl rule__GridPropIndicatorStyle__Group__4 ) |
| // InternalGridSource.g:2870:2: rule__GridPropIndicatorStyle__Group__3__Impl rule__GridPropIndicatorStyle__Group__4 |
| { |
| pushFollow(FOLLOW_34); |
| rule__GridPropIndicatorStyle__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__GridPropIndicatorStyle__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__3" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__3__Impl" |
| // InternalGridSource.g:2877:1: rule__GridPropIndicatorStyle__Group__3__Impl : ( ( rule__GridPropIndicatorStyle__GreenStartsAssignment_3 ) ) ; |
| public final void rule__GridPropIndicatorStyle__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2881:1: ( ( ( rule__GridPropIndicatorStyle__GreenStartsAssignment_3 ) ) ) |
| // InternalGridSource.g:2882:1: ( ( rule__GridPropIndicatorStyle__GreenStartsAssignment_3 ) ) |
| { |
| // InternalGridSource.g:2882:1: ( ( rule__GridPropIndicatorStyle__GreenStartsAssignment_3 ) ) |
| // InternalGridSource.g:2883:2: ( rule__GridPropIndicatorStyle__GreenStartsAssignment_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getGridPropIndicatorStyleAccess().getGreenStartsAssignment_3()); |
| } |
| // InternalGridSource.g:2884:2: ( rule__GridPropIndicatorStyle__GreenStartsAssignment_3 ) |
| // InternalGridSource.g:2884:3: rule__GridPropIndicatorStyle__GreenStartsAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__GridPropIndicatorStyle__GreenStartsAssignment_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getGridPropIndicatorStyleAccess().getGreenStartsAssignment_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__4" |
| // InternalGridSource.g:2892:1: rule__GridPropIndicatorStyle__Group__4 : rule__GridPropIndicatorStyle__Group__4__Impl rule__GridPropIndicatorStyle__Group__5 ; |
| public final void rule__GridPropIndicatorStyle__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2896:1: ( rule__GridPropIndicatorStyle__Group__4__Impl rule__GridPropIndicatorStyle__Group__5 ) |
| // InternalGridSource.g:2897:2: rule__GridPropIndicatorStyle__Group__4__Impl rule__GridPropIndicatorStyle__Group__5 |
| { |
| pushFollow(FOLLOW_32); |
| rule__GridPropIndicatorStyle__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__GridPropIndicatorStyle__Group__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__4" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__4__Impl" |
| // InternalGridSource.g:2904:1: rule__GridPropIndicatorStyle__Group__4__Impl : ( 'redUntil' ) ; |
| public final void rule__GridPropIndicatorStyle__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2908:1: ( ( 'redUntil' ) ) |
| // InternalGridSource.g:2909:1: ( 'redUntil' ) |
| { |
| // InternalGridSource.g:2909:1: ( 'redUntil' ) |
| // InternalGridSource.g:2910:2: 'redUntil' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getGridPropIndicatorStyleAccess().getRedUntilKeyword_4()); |
| } |
| match(input,46,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getGridPropIndicatorStyleAccess().getRedUntilKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__5" |
| // InternalGridSource.g:2919:1: rule__GridPropIndicatorStyle__Group__5 : rule__GridPropIndicatorStyle__Group__5__Impl ; |
| public final void rule__GridPropIndicatorStyle__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2923:1: ( rule__GridPropIndicatorStyle__Group__5__Impl ) |
| // InternalGridSource.g:2924:2: rule__GridPropIndicatorStyle__Group__5__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__GridPropIndicatorStyle__Group__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__5" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__Group__5__Impl" |
| // InternalGridSource.g:2930:1: rule__GridPropIndicatorStyle__Group__5__Impl : ( ( rule__GridPropIndicatorStyle__RedEndsAssignment_5 ) ) ; |
| public final void rule__GridPropIndicatorStyle__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2934:1: ( ( ( rule__GridPropIndicatorStyle__RedEndsAssignment_5 ) ) ) |
| // InternalGridSource.g:2935:1: ( ( rule__GridPropIndicatorStyle__RedEndsAssignment_5 ) ) |
| { |
| // InternalGridSource.g:2935:1: ( ( rule__GridPropIndicatorStyle__RedEndsAssignment_5 ) ) |
| // InternalGridSource.g:2936:2: ( rule__GridPropIndicatorStyle__RedEndsAssignment_5 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getGridPropIndicatorStyleAccess().getRedEndsAssignment_5()); |
| } |
| // InternalGridSource.g:2937:2: ( rule__GridPropIndicatorStyle__RedEndsAssignment_5 ) |
| // InternalGridSource.g:2937:3: rule__GridPropIndicatorStyle__RedEndsAssignment_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__GridPropIndicatorStyle__RedEndsAssignment_5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getGridPropIndicatorStyleAccess().getRedEndsAssignment_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__0" |
| // InternalGridSource.g:2946:1: rule__PropertyQuantityStyle__Group__0 : rule__PropertyQuantityStyle__Group__0__Impl rule__PropertyQuantityStyle__Group__1 ; |
| public final void rule__PropertyQuantityStyle__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2950:1: ( rule__PropertyQuantityStyle__Group__0__Impl rule__PropertyQuantityStyle__Group__1 ) |
| // InternalGridSource.g:2951:2: rule__PropertyQuantityStyle__Group__0__Impl rule__PropertyQuantityStyle__Group__1 |
| { |
| pushFollow(FOLLOW_35); |
| rule__PropertyQuantityStyle__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__0" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__0__Impl" |
| // InternalGridSource.g:2958:1: rule__PropertyQuantityStyle__Group__0__Impl : ( () ) ; |
| public final void rule__PropertyQuantityStyle__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2962:1: ( ( () ) ) |
| // InternalGridSource.g:2963:1: ( () ) |
| { |
| // InternalGridSource.g:2963:1: ( () ) |
| // InternalGridSource.g:2964:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getCxGridPropQuantityStyleAction_0()); |
| } |
| // InternalGridSource.g:2965:2: () |
| // InternalGridSource.g:2965:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getCxGridPropQuantityStyleAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__1" |
| // InternalGridSource.g:2973:1: rule__PropertyQuantityStyle__Group__1 : rule__PropertyQuantityStyle__Group__1__Impl rule__PropertyQuantityStyle__Group__2 ; |
| public final void rule__PropertyQuantityStyle__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2977:1: ( rule__PropertyQuantityStyle__Group__1__Impl rule__PropertyQuantityStyle__Group__2 ) |
| // InternalGridSource.g:2978:2: rule__PropertyQuantityStyle__Group__1__Impl rule__PropertyQuantityStyle__Group__2 |
| { |
| pushFollow(FOLLOW_36); |
| rule__PropertyQuantityStyle__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__1" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__1__Impl" |
| // InternalGridSource.g:2985:1: rule__PropertyQuantityStyle__Group__1__Impl : ( 'quantityStyle' ) ; |
| public final void rule__PropertyQuantityStyle__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:2989:1: ( ( 'quantityStyle' ) ) |
| // InternalGridSource.g:2990:1: ( 'quantityStyle' ) |
| { |
| // InternalGridSource.g:2990:1: ( 'quantityStyle' ) |
| // InternalGridSource.g:2991:2: 'quantityStyle' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getQuantityStyleKeyword_1()); |
| } |
| match(input,47,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getQuantityStyleKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__2" |
| // InternalGridSource.g:3000:1: rule__PropertyQuantityStyle__Group__2 : rule__PropertyQuantityStyle__Group__2__Impl rule__PropertyQuantityStyle__Group__3 ; |
| public final void rule__PropertyQuantityStyle__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3004:1: ( rule__PropertyQuantityStyle__Group__2__Impl rule__PropertyQuantityStyle__Group__3 ) |
| // InternalGridSource.g:3005:2: rule__PropertyQuantityStyle__Group__2__Impl rule__PropertyQuantityStyle__Group__3 |
| { |
| pushFollow(FOLLOW_36); |
| rule__PropertyQuantityStyle__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__2" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__2__Impl" |
| // InternalGridSource.g:3012:1: rule__PropertyQuantityStyle__Group__2__Impl : ( ( rule__PropertyQuantityStyle__HtmlPatternAssignment_2 )? ) ; |
| public final void rule__PropertyQuantityStyle__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3016:1: ( ( ( rule__PropertyQuantityStyle__HtmlPatternAssignment_2 )? ) ) |
| // InternalGridSource.g:3017:1: ( ( rule__PropertyQuantityStyle__HtmlPatternAssignment_2 )? ) |
| { |
| // InternalGridSource.g:3017:1: ( ( rule__PropertyQuantityStyle__HtmlPatternAssignment_2 )? ) |
| // InternalGridSource.g:3018:2: ( rule__PropertyQuantityStyle__HtmlPatternAssignment_2 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getHtmlPatternAssignment_2()); |
| } |
| // InternalGridSource.g:3019:2: ( rule__PropertyQuantityStyle__HtmlPatternAssignment_2 )? |
| int alt16=2; |
| int LA16_0 = input.LA(1); |
| |
| if ( (LA16_0==RULE_STRING) ) { |
| alt16=1; |
| } |
| switch (alt16) { |
| case 1 : |
| // InternalGridSource.g:3019:3: rule__PropertyQuantityStyle__HtmlPatternAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__HtmlPatternAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getHtmlPatternAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__3" |
| // InternalGridSource.g:3027:1: rule__PropertyQuantityStyle__Group__3 : rule__PropertyQuantityStyle__Group__3__Impl rule__PropertyQuantityStyle__Group__4 ; |
| public final void rule__PropertyQuantityStyle__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3031:1: ( rule__PropertyQuantityStyle__Group__3__Impl rule__PropertyQuantityStyle__Group__4 ) |
| // InternalGridSource.g:3032:2: rule__PropertyQuantityStyle__Group__3__Impl rule__PropertyQuantityStyle__Group__4 |
| { |
| pushFollow(FOLLOW_17); |
| rule__PropertyQuantityStyle__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__3" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__3__Impl" |
| // InternalGridSource.g:3039:1: rule__PropertyQuantityStyle__Group__3__Impl : ( 'value' ) ; |
| public final void rule__PropertyQuantityStyle__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3043:1: ( ( 'value' ) ) |
| // InternalGridSource.g:3044:1: ( 'value' ) |
| { |
| // InternalGridSource.g:3044:1: ( 'value' ) |
| // InternalGridSource.g:3045:2: 'value' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getValueKeyword_3()); |
| } |
| match(input,48,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getValueKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__4" |
| // InternalGridSource.g:3054:1: rule__PropertyQuantityStyle__Group__4 : rule__PropertyQuantityStyle__Group__4__Impl rule__PropertyQuantityStyle__Group__5 ; |
| public final void rule__PropertyQuantityStyle__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3058:1: ( rule__PropertyQuantityStyle__Group__4__Impl rule__PropertyQuantityStyle__Group__5 ) |
| // InternalGridSource.g:3059:2: rule__PropertyQuantityStyle__Group__4__Impl rule__PropertyQuantityStyle__Group__5 |
| { |
| pushFollow(FOLLOW_4); |
| rule__PropertyQuantityStyle__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__4" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__4__Impl" |
| // InternalGridSource.g:3066:1: rule__PropertyQuantityStyle__Group__4__Impl : ( '=' ) ; |
| public final void rule__PropertyQuantityStyle__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3070:1: ( ( '=' ) ) |
| // InternalGridSource.g:3071:1: ( '=' ) |
| { |
| // InternalGridSource.g:3071:1: ( '=' ) |
| // InternalGridSource.g:3072:2: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getEqualsSignKeyword_4()); |
| } |
| match(input,30,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getEqualsSignKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__5" |
| // InternalGridSource.g:3081:1: rule__PropertyQuantityStyle__Group__5 : rule__PropertyQuantityStyle__Group__5__Impl rule__PropertyQuantityStyle__Group__6 ; |
| public final void rule__PropertyQuantityStyle__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3085:1: ( rule__PropertyQuantityStyle__Group__5__Impl rule__PropertyQuantityStyle__Group__6 ) |
| // InternalGridSource.g:3086:2: rule__PropertyQuantityStyle__Group__5__Impl rule__PropertyQuantityStyle__Group__6 |
| { |
| pushFollow(FOLLOW_37); |
| rule__PropertyQuantityStyle__Group__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group__6(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__5" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__5__Impl" |
| // InternalGridSource.g:3093:1: rule__PropertyQuantityStyle__Group__5__Impl : ( ( rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5 ) ) ; |
| public final void rule__PropertyQuantityStyle__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3097:1: ( ( ( rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5 ) ) ) |
| // InternalGridSource.g:3098:1: ( ( rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5 ) ) |
| { |
| // InternalGridSource.g:3098:1: ( ( rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5 ) ) |
| // InternalGridSource.g:3099:2: ( rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getValuePropertyPathAssignment_5()); |
| } |
| // InternalGridSource.g:3100:2: ( rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5 ) |
| // InternalGridSource.g:3100:3: rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getValuePropertyPathAssignment_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__6" |
| // InternalGridSource.g:3108:1: rule__PropertyQuantityStyle__Group__6 : rule__PropertyQuantityStyle__Group__6__Impl rule__PropertyQuantityStyle__Group__7 ; |
| public final void rule__PropertyQuantityStyle__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3112:1: ( rule__PropertyQuantityStyle__Group__6__Impl rule__PropertyQuantityStyle__Group__7 ) |
| // InternalGridSource.g:3113:2: rule__PropertyQuantityStyle__Group__6__Impl rule__PropertyQuantityStyle__Group__7 |
| { |
| pushFollow(FOLLOW_37); |
| rule__PropertyQuantityStyle__Group__6__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group__7(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__6" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__6__Impl" |
| // InternalGridSource.g:3120:1: rule__PropertyQuantityStyle__Group__6__Impl : ( ( rule__PropertyQuantityStyle__Group_6__0 )? ) ; |
| public final void rule__PropertyQuantityStyle__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3124:1: ( ( ( rule__PropertyQuantityStyle__Group_6__0 )? ) ) |
| // InternalGridSource.g:3125:1: ( ( rule__PropertyQuantityStyle__Group_6__0 )? ) |
| { |
| // InternalGridSource.g:3125:1: ( ( rule__PropertyQuantityStyle__Group_6__0 )? ) |
| // InternalGridSource.g:3126:2: ( rule__PropertyQuantityStyle__Group_6__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getGroup_6()); |
| } |
| // InternalGridSource.g:3127:2: ( rule__PropertyQuantityStyle__Group_6__0 )? |
| int alt17=2; |
| int LA17_0 = input.LA(1); |
| |
| if ( (LA17_0==50) ) { |
| alt17=1; |
| } |
| switch (alt17) { |
| case 1 : |
| // InternalGridSource.g:3127:3: rule__PropertyQuantityStyle__Group_6__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group_6__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getGroup_6()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__7" |
| // InternalGridSource.g:3135:1: rule__PropertyQuantityStyle__Group__7 : rule__PropertyQuantityStyle__Group__7__Impl rule__PropertyQuantityStyle__Group__8 ; |
| public final void rule__PropertyQuantityStyle__Group__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3139:1: ( rule__PropertyQuantityStyle__Group__7__Impl rule__PropertyQuantityStyle__Group__8 ) |
| // InternalGridSource.g:3140:2: rule__PropertyQuantityStyle__Group__7__Impl rule__PropertyQuantityStyle__Group__8 |
| { |
| pushFollow(FOLLOW_17); |
| rule__PropertyQuantityStyle__Group__7__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group__8(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__7" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__7__Impl" |
| // InternalGridSource.g:3147:1: rule__PropertyQuantityStyle__Group__7__Impl : ( 'uom' ) ; |
| public final void rule__PropertyQuantityStyle__Group__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3151:1: ( ( 'uom' ) ) |
| // InternalGridSource.g:3152:1: ( 'uom' ) |
| { |
| // InternalGridSource.g:3152:1: ( 'uom' ) |
| // InternalGridSource.g:3153:2: 'uom' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getUomKeyword_7()); |
| } |
| match(input,49,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getUomKeyword_7()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__7__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__8" |
| // InternalGridSource.g:3162:1: rule__PropertyQuantityStyle__Group__8 : rule__PropertyQuantityStyle__Group__8__Impl rule__PropertyQuantityStyle__Group__9 ; |
| public final void rule__PropertyQuantityStyle__Group__8() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3166:1: ( rule__PropertyQuantityStyle__Group__8__Impl rule__PropertyQuantityStyle__Group__9 ) |
| // InternalGridSource.g:3167:2: rule__PropertyQuantityStyle__Group__8__Impl rule__PropertyQuantityStyle__Group__9 |
| { |
| pushFollow(FOLLOW_4); |
| rule__PropertyQuantityStyle__Group__8__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group__9(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__8" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__8__Impl" |
| // InternalGridSource.g:3174:1: rule__PropertyQuantityStyle__Group__8__Impl : ( '=' ) ; |
| public final void rule__PropertyQuantityStyle__Group__8__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3178:1: ( ( '=' ) ) |
| // InternalGridSource.g:3179:1: ( '=' ) |
| { |
| // InternalGridSource.g:3179:1: ( '=' ) |
| // InternalGridSource.g:3180:2: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getEqualsSignKeyword_8()); |
| } |
| match(input,30,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getEqualsSignKeyword_8()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__8__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__9" |
| // InternalGridSource.g:3189:1: rule__PropertyQuantityStyle__Group__9 : rule__PropertyQuantityStyle__Group__9__Impl ; |
| public final void rule__PropertyQuantityStyle__Group__9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3193:1: ( rule__PropertyQuantityStyle__Group__9__Impl ) |
| // InternalGridSource.g:3194:2: rule__PropertyQuantityStyle__Group__9__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group__9__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__9" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group__9__Impl" |
| // InternalGridSource.g:3200:1: rule__PropertyQuantityStyle__Group__9__Impl : ( ( rule__PropertyQuantityStyle__UomPropertyPathAssignment_9 ) ) ; |
| public final void rule__PropertyQuantityStyle__Group__9__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3204:1: ( ( ( rule__PropertyQuantityStyle__UomPropertyPathAssignment_9 ) ) ) |
| // InternalGridSource.g:3205:1: ( ( rule__PropertyQuantityStyle__UomPropertyPathAssignment_9 ) ) |
| { |
| // InternalGridSource.g:3205:1: ( ( rule__PropertyQuantityStyle__UomPropertyPathAssignment_9 ) ) |
| // InternalGridSource.g:3206:2: ( rule__PropertyQuantityStyle__UomPropertyPathAssignment_9 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getUomPropertyPathAssignment_9()); |
| } |
| // InternalGridSource.g:3207:2: ( rule__PropertyQuantityStyle__UomPropertyPathAssignment_9 ) |
| // InternalGridSource.g:3207:3: rule__PropertyQuantityStyle__UomPropertyPathAssignment_9 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__UomPropertyPathAssignment_9(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getUomPropertyPathAssignment_9()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group__9__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group_6__0" |
| // InternalGridSource.g:3216:1: rule__PropertyQuantityStyle__Group_6__0 : rule__PropertyQuantityStyle__Group_6__0__Impl rule__PropertyQuantityStyle__Group_6__1 ; |
| public final void rule__PropertyQuantityStyle__Group_6__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3220:1: ( rule__PropertyQuantityStyle__Group_6__0__Impl rule__PropertyQuantityStyle__Group_6__1 ) |
| // InternalGridSource.g:3221:2: rule__PropertyQuantityStyle__Group_6__0__Impl rule__PropertyQuantityStyle__Group_6__1 |
| { |
| pushFollow(FOLLOW_28); |
| rule__PropertyQuantityStyle__Group_6__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group_6__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group_6__0" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group_6__0__Impl" |
| // InternalGridSource.g:3228:1: rule__PropertyQuantityStyle__Group_6__0__Impl : ( '(' ) ; |
| public final void rule__PropertyQuantityStyle__Group_6__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3232:1: ( ( '(' ) ) |
| // InternalGridSource.g:3233:1: ( '(' ) |
| { |
| // InternalGridSource.g:3233:1: ( '(' ) |
| // InternalGridSource.g:3234:2: '(' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getLeftParenthesisKeyword_6_0()); |
| } |
| match(input,50,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getLeftParenthesisKeyword_6_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group_6__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group_6__1" |
| // InternalGridSource.g:3243:1: rule__PropertyQuantityStyle__Group_6__1 : rule__PropertyQuantityStyle__Group_6__1__Impl rule__PropertyQuantityStyle__Group_6__2 ; |
| public final void rule__PropertyQuantityStyle__Group_6__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3247:1: ( rule__PropertyQuantityStyle__Group_6__1__Impl rule__PropertyQuantityStyle__Group_6__2 ) |
| // InternalGridSource.g:3248:2: rule__PropertyQuantityStyle__Group_6__1__Impl rule__PropertyQuantityStyle__Group_6__2 |
| { |
| pushFollow(FOLLOW_24); |
| rule__PropertyQuantityStyle__Group_6__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group_6__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group_6__1" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group_6__1__Impl" |
| // InternalGridSource.g:3255:1: rule__PropertyQuantityStyle__Group_6__1__Impl : ( 'format' ) ; |
| public final void rule__PropertyQuantityStyle__Group_6__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3259:1: ( ( 'format' ) ) |
| // InternalGridSource.g:3260:1: ( 'format' ) |
| { |
| // InternalGridSource.g:3260:1: ( 'format' ) |
| // InternalGridSource.g:3261:2: 'format' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getFormatKeyword_6_1()); |
| } |
| match(input,40,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getFormatKeyword_6_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group_6__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group_6__2" |
| // InternalGridSource.g:3270:1: rule__PropertyQuantityStyle__Group_6__2 : rule__PropertyQuantityStyle__Group_6__2__Impl rule__PropertyQuantityStyle__Group_6__3 ; |
| public final void rule__PropertyQuantityStyle__Group_6__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3274:1: ( rule__PropertyQuantityStyle__Group_6__2__Impl rule__PropertyQuantityStyle__Group_6__3 ) |
| // InternalGridSource.g:3275:2: rule__PropertyQuantityStyle__Group_6__2__Impl rule__PropertyQuantityStyle__Group_6__3 |
| { |
| pushFollow(FOLLOW_38); |
| rule__PropertyQuantityStyle__Group_6__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group_6__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group_6__2" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group_6__2__Impl" |
| // InternalGridSource.g:3282:1: rule__PropertyQuantityStyle__Group_6__2__Impl : ( ( rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2 ) ) ; |
| public final void rule__PropertyQuantityStyle__Group_6__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3286:1: ( ( ( rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2 ) ) ) |
| // InternalGridSource.g:3287:1: ( ( rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2 ) ) |
| { |
| // InternalGridSource.g:3287:1: ( ( rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2 ) ) |
| // InternalGridSource.g:3288:2: ( rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getValueNumberFormatAssignment_6_2()); |
| } |
| // InternalGridSource.g:3289:2: ( rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2 ) |
| // InternalGridSource.g:3289:3: rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getValueNumberFormatAssignment_6_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group_6__2__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group_6__3" |
| // InternalGridSource.g:3297:1: rule__PropertyQuantityStyle__Group_6__3 : rule__PropertyQuantityStyle__Group_6__3__Impl ; |
| public final void rule__PropertyQuantityStyle__Group_6__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3301:1: ( rule__PropertyQuantityStyle__Group_6__3__Impl ) |
| // InternalGridSource.g:3302:2: rule__PropertyQuantityStyle__Group_6__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyQuantityStyle__Group_6__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group_6__3" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__Group_6__3__Impl" |
| // InternalGridSource.g:3308:1: rule__PropertyQuantityStyle__Group_6__3__Impl : ( ')' ) ; |
| public final void rule__PropertyQuantityStyle__Group_6__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3312:1: ( ( ')' ) ) |
| // InternalGridSource.g:3313:1: ( ')' ) |
| { |
| // InternalGridSource.g:3313:1: ( ')' ) |
| // InternalGridSource.g:3314:2: ')' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getRightParenthesisKeyword_6_3()); |
| } |
| match(input,51,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getRightParenthesisKeyword_6_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__Group_6__3__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__0" |
| // InternalGridSource.g:3324:1: rule__PropertyPriceStyle__Group__0 : rule__PropertyPriceStyle__Group__0__Impl rule__PropertyPriceStyle__Group__1 ; |
| public final void rule__PropertyPriceStyle__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3328:1: ( rule__PropertyPriceStyle__Group__0__Impl rule__PropertyPriceStyle__Group__1 ) |
| // InternalGridSource.g:3329:2: rule__PropertyPriceStyle__Group__0__Impl rule__PropertyPriceStyle__Group__1 |
| { |
| pushFollow(FOLLOW_39); |
| rule__PropertyPriceStyle__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__0" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__0__Impl" |
| // InternalGridSource.g:3336:1: rule__PropertyPriceStyle__Group__0__Impl : ( () ) ; |
| public final void rule__PropertyPriceStyle__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3340:1: ( ( () ) ) |
| // InternalGridSource.g:3341:1: ( () ) |
| { |
| // InternalGridSource.g:3341:1: ( () ) |
| // InternalGridSource.g:3342:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getCxGridPropPriceStyleAction_0()); |
| } |
| // InternalGridSource.g:3343:2: () |
| // InternalGridSource.g:3343:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getCxGridPropPriceStyleAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__1" |
| // InternalGridSource.g:3351:1: rule__PropertyPriceStyle__Group__1 : rule__PropertyPriceStyle__Group__1__Impl rule__PropertyPriceStyle__Group__2 ; |
| public final void rule__PropertyPriceStyle__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3355:1: ( rule__PropertyPriceStyle__Group__1__Impl rule__PropertyPriceStyle__Group__2 ) |
| // InternalGridSource.g:3356:2: rule__PropertyPriceStyle__Group__1__Impl rule__PropertyPriceStyle__Group__2 |
| { |
| pushFollow(FOLLOW_36); |
| rule__PropertyPriceStyle__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__1" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__1__Impl" |
| // InternalGridSource.g:3363:1: rule__PropertyPriceStyle__Group__1__Impl : ( 'priceStyle' ) ; |
| public final void rule__PropertyPriceStyle__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3367:1: ( ( 'priceStyle' ) ) |
| // InternalGridSource.g:3368:1: ( 'priceStyle' ) |
| { |
| // InternalGridSource.g:3368:1: ( 'priceStyle' ) |
| // InternalGridSource.g:3369:2: 'priceStyle' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getPriceStyleKeyword_1()); |
| } |
| match(input,52,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getPriceStyleKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__2" |
| // InternalGridSource.g:3378:1: rule__PropertyPriceStyle__Group__2 : rule__PropertyPriceStyle__Group__2__Impl rule__PropertyPriceStyle__Group__3 ; |
| public final void rule__PropertyPriceStyle__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3382:1: ( rule__PropertyPriceStyle__Group__2__Impl rule__PropertyPriceStyle__Group__3 ) |
| // InternalGridSource.g:3383:2: rule__PropertyPriceStyle__Group__2__Impl rule__PropertyPriceStyle__Group__3 |
| { |
| pushFollow(FOLLOW_36); |
| rule__PropertyPriceStyle__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__2" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__2__Impl" |
| // InternalGridSource.g:3390:1: rule__PropertyPriceStyle__Group__2__Impl : ( ( rule__PropertyPriceStyle__HtmlPatternAssignment_2 )? ) ; |
| public final void rule__PropertyPriceStyle__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3394:1: ( ( ( rule__PropertyPriceStyle__HtmlPatternAssignment_2 )? ) ) |
| // InternalGridSource.g:3395:1: ( ( rule__PropertyPriceStyle__HtmlPatternAssignment_2 )? ) |
| { |
| // InternalGridSource.g:3395:1: ( ( rule__PropertyPriceStyle__HtmlPatternAssignment_2 )? ) |
| // InternalGridSource.g:3396:2: ( rule__PropertyPriceStyle__HtmlPatternAssignment_2 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getHtmlPatternAssignment_2()); |
| } |
| // InternalGridSource.g:3397:2: ( rule__PropertyPriceStyle__HtmlPatternAssignment_2 )? |
| int alt18=2; |
| int LA18_0 = input.LA(1); |
| |
| if ( (LA18_0==RULE_STRING) ) { |
| alt18=1; |
| } |
| switch (alt18) { |
| case 1 : |
| // InternalGridSource.g:3397:3: rule__PropertyPriceStyle__HtmlPatternAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__HtmlPatternAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getHtmlPatternAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__3" |
| // InternalGridSource.g:3405:1: rule__PropertyPriceStyle__Group__3 : rule__PropertyPriceStyle__Group__3__Impl rule__PropertyPriceStyle__Group__4 ; |
| public final void rule__PropertyPriceStyle__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3409:1: ( rule__PropertyPriceStyle__Group__3__Impl rule__PropertyPriceStyle__Group__4 ) |
| // InternalGridSource.g:3410:2: rule__PropertyPriceStyle__Group__3__Impl rule__PropertyPriceStyle__Group__4 |
| { |
| pushFollow(FOLLOW_17); |
| rule__PropertyPriceStyle__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__3" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__3__Impl" |
| // InternalGridSource.g:3417:1: rule__PropertyPriceStyle__Group__3__Impl : ( 'value' ) ; |
| public final void rule__PropertyPriceStyle__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3421:1: ( ( 'value' ) ) |
| // InternalGridSource.g:3422:1: ( 'value' ) |
| { |
| // InternalGridSource.g:3422:1: ( 'value' ) |
| // InternalGridSource.g:3423:2: 'value' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getValueKeyword_3()); |
| } |
| match(input,48,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getValueKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__4" |
| // InternalGridSource.g:3432:1: rule__PropertyPriceStyle__Group__4 : rule__PropertyPriceStyle__Group__4__Impl rule__PropertyPriceStyle__Group__5 ; |
| public final void rule__PropertyPriceStyle__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3436:1: ( rule__PropertyPriceStyle__Group__4__Impl rule__PropertyPriceStyle__Group__5 ) |
| // InternalGridSource.g:3437:2: rule__PropertyPriceStyle__Group__4__Impl rule__PropertyPriceStyle__Group__5 |
| { |
| pushFollow(FOLLOW_4); |
| rule__PropertyPriceStyle__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__4" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__4__Impl" |
| // InternalGridSource.g:3444:1: rule__PropertyPriceStyle__Group__4__Impl : ( '=' ) ; |
| public final void rule__PropertyPriceStyle__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3448:1: ( ( '=' ) ) |
| // InternalGridSource.g:3449:1: ( '=' ) |
| { |
| // InternalGridSource.g:3449:1: ( '=' ) |
| // InternalGridSource.g:3450:2: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getEqualsSignKeyword_4()); |
| } |
| match(input,30,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getEqualsSignKeyword_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__5" |
| // InternalGridSource.g:3459:1: rule__PropertyPriceStyle__Group__5 : rule__PropertyPriceStyle__Group__5__Impl rule__PropertyPriceStyle__Group__6 ; |
| public final void rule__PropertyPriceStyle__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3463:1: ( rule__PropertyPriceStyle__Group__5__Impl rule__PropertyPriceStyle__Group__6 ) |
| // InternalGridSource.g:3464:2: rule__PropertyPriceStyle__Group__5__Impl rule__PropertyPriceStyle__Group__6 |
| { |
| pushFollow(FOLLOW_40); |
| rule__PropertyPriceStyle__Group__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group__6(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__5" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__5__Impl" |
| // InternalGridSource.g:3471:1: rule__PropertyPriceStyle__Group__5__Impl : ( ( rule__PropertyPriceStyle__ValuePropertyPathAssignment_5 ) ) ; |
| public final void rule__PropertyPriceStyle__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3475:1: ( ( ( rule__PropertyPriceStyle__ValuePropertyPathAssignment_5 ) ) ) |
| // InternalGridSource.g:3476:1: ( ( rule__PropertyPriceStyle__ValuePropertyPathAssignment_5 ) ) |
| { |
| // InternalGridSource.g:3476:1: ( ( rule__PropertyPriceStyle__ValuePropertyPathAssignment_5 ) ) |
| // InternalGridSource.g:3477:2: ( rule__PropertyPriceStyle__ValuePropertyPathAssignment_5 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getValuePropertyPathAssignment_5()); |
| } |
| // InternalGridSource.g:3478:2: ( rule__PropertyPriceStyle__ValuePropertyPathAssignment_5 ) |
| // InternalGridSource.g:3478:3: rule__PropertyPriceStyle__ValuePropertyPathAssignment_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__ValuePropertyPathAssignment_5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getValuePropertyPathAssignment_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__6" |
| // InternalGridSource.g:3486:1: rule__PropertyPriceStyle__Group__6 : rule__PropertyPriceStyle__Group__6__Impl rule__PropertyPriceStyle__Group__7 ; |
| public final void rule__PropertyPriceStyle__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3490:1: ( rule__PropertyPriceStyle__Group__6__Impl rule__PropertyPriceStyle__Group__7 ) |
| // InternalGridSource.g:3491:2: rule__PropertyPriceStyle__Group__6__Impl rule__PropertyPriceStyle__Group__7 |
| { |
| pushFollow(FOLLOW_40); |
| rule__PropertyPriceStyle__Group__6__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group__7(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__6" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__6__Impl" |
| // InternalGridSource.g:3498:1: rule__PropertyPriceStyle__Group__6__Impl : ( ( rule__PropertyPriceStyle__Group_6__0 )? ) ; |
| public final void rule__PropertyPriceStyle__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3502:1: ( ( ( rule__PropertyPriceStyle__Group_6__0 )? ) ) |
| // InternalGridSource.g:3503:1: ( ( rule__PropertyPriceStyle__Group_6__0 )? ) |
| { |
| // InternalGridSource.g:3503:1: ( ( rule__PropertyPriceStyle__Group_6__0 )? ) |
| // InternalGridSource.g:3504:2: ( rule__PropertyPriceStyle__Group_6__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getGroup_6()); |
| } |
| // InternalGridSource.g:3505:2: ( rule__PropertyPriceStyle__Group_6__0 )? |
| int alt19=2; |
| int LA19_0 = input.LA(1); |
| |
| if ( (LA19_0==50) ) { |
| alt19=1; |
| } |
| switch (alt19) { |
| case 1 : |
| // InternalGridSource.g:3505:3: rule__PropertyPriceStyle__Group_6__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group_6__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getGroup_6()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__7" |
| // InternalGridSource.g:3513:1: rule__PropertyPriceStyle__Group__7 : rule__PropertyPriceStyle__Group__7__Impl rule__PropertyPriceStyle__Group__8 ; |
| public final void rule__PropertyPriceStyle__Group__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3517:1: ( rule__PropertyPriceStyle__Group__7__Impl rule__PropertyPriceStyle__Group__8 ) |
| // InternalGridSource.g:3518:2: rule__PropertyPriceStyle__Group__7__Impl rule__PropertyPriceStyle__Group__8 |
| { |
| pushFollow(FOLLOW_17); |
| rule__PropertyPriceStyle__Group__7__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group__8(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__7" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__7__Impl" |
| // InternalGridSource.g:3525:1: rule__PropertyPriceStyle__Group__7__Impl : ( 'currency' ) ; |
| public final void rule__PropertyPriceStyle__Group__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3529:1: ( ( 'currency' ) ) |
| // InternalGridSource.g:3530:1: ( 'currency' ) |
| { |
| // InternalGridSource.g:3530:1: ( 'currency' ) |
| // InternalGridSource.g:3531:2: 'currency' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getCurrencyKeyword_7()); |
| } |
| match(input,53,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getCurrencyKeyword_7()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__7__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__8" |
| // InternalGridSource.g:3540:1: rule__PropertyPriceStyle__Group__8 : rule__PropertyPriceStyle__Group__8__Impl rule__PropertyPriceStyle__Group__9 ; |
| public final void rule__PropertyPriceStyle__Group__8() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3544:1: ( rule__PropertyPriceStyle__Group__8__Impl rule__PropertyPriceStyle__Group__9 ) |
| // InternalGridSource.g:3545:2: rule__PropertyPriceStyle__Group__8__Impl rule__PropertyPriceStyle__Group__9 |
| { |
| pushFollow(FOLLOW_4); |
| rule__PropertyPriceStyle__Group__8__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group__9(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__8" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__8__Impl" |
| // InternalGridSource.g:3552:1: rule__PropertyPriceStyle__Group__8__Impl : ( '=' ) ; |
| public final void rule__PropertyPriceStyle__Group__8__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3556:1: ( ( '=' ) ) |
| // InternalGridSource.g:3557:1: ( '=' ) |
| { |
| // InternalGridSource.g:3557:1: ( '=' ) |
| // InternalGridSource.g:3558:2: '=' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getEqualsSignKeyword_8()); |
| } |
| match(input,30,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getEqualsSignKeyword_8()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__8__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__9" |
| // InternalGridSource.g:3567:1: rule__PropertyPriceStyle__Group__9 : rule__PropertyPriceStyle__Group__9__Impl ; |
| public final void rule__PropertyPriceStyle__Group__9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3571:1: ( rule__PropertyPriceStyle__Group__9__Impl ) |
| // InternalGridSource.g:3572:2: rule__PropertyPriceStyle__Group__9__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group__9__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__9" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group__9__Impl" |
| // InternalGridSource.g:3578:1: rule__PropertyPriceStyle__Group__9__Impl : ( ( rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9 ) ) ; |
| public final void rule__PropertyPriceStyle__Group__9__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3582:1: ( ( ( rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9 ) ) ) |
| // InternalGridSource.g:3583:1: ( ( rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9 ) ) |
| { |
| // InternalGridSource.g:3583:1: ( ( rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9 ) ) |
| // InternalGridSource.g:3584:2: ( rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getCurrencyPropertyPathAssignment_9()); |
| } |
| // InternalGridSource.g:3585:2: ( rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9 ) |
| // InternalGridSource.g:3585:3: rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getCurrencyPropertyPathAssignment_9()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group__9__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group_6__0" |
| // InternalGridSource.g:3594:1: rule__PropertyPriceStyle__Group_6__0 : rule__PropertyPriceStyle__Group_6__0__Impl rule__PropertyPriceStyle__Group_6__1 ; |
| public final void rule__PropertyPriceStyle__Group_6__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3598:1: ( rule__PropertyPriceStyle__Group_6__0__Impl rule__PropertyPriceStyle__Group_6__1 ) |
| // InternalGridSource.g:3599:2: rule__PropertyPriceStyle__Group_6__0__Impl rule__PropertyPriceStyle__Group_6__1 |
| { |
| pushFollow(FOLLOW_28); |
| rule__PropertyPriceStyle__Group_6__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group_6__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group_6__0" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group_6__0__Impl" |
| // InternalGridSource.g:3606:1: rule__PropertyPriceStyle__Group_6__0__Impl : ( '(' ) ; |
| public final void rule__PropertyPriceStyle__Group_6__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3610:1: ( ( '(' ) ) |
| // InternalGridSource.g:3611:1: ( '(' ) |
| { |
| // InternalGridSource.g:3611:1: ( '(' ) |
| // InternalGridSource.g:3612:2: '(' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getLeftParenthesisKeyword_6_0()); |
| } |
| match(input,50,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getLeftParenthesisKeyword_6_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group_6__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group_6__1" |
| // InternalGridSource.g:3621:1: rule__PropertyPriceStyle__Group_6__1 : rule__PropertyPriceStyle__Group_6__1__Impl rule__PropertyPriceStyle__Group_6__2 ; |
| public final void rule__PropertyPriceStyle__Group_6__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3625:1: ( rule__PropertyPriceStyle__Group_6__1__Impl rule__PropertyPriceStyle__Group_6__2 ) |
| // InternalGridSource.g:3626:2: rule__PropertyPriceStyle__Group_6__1__Impl rule__PropertyPriceStyle__Group_6__2 |
| { |
| pushFollow(FOLLOW_24); |
| rule__PropertyPriceStyle__Group_6__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group_6__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group_6__1" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group_6__1__Impl" |
| // InternalGridSource.g:3633:1: rule__PropertyPriceStyle__Group_6__1__Impl : ( 'format' ) ; |
| public final void rule__PropertyPriceStyle__Group_6__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3637:1: ( ( 'format' ) ) |
| // InternalGridSource.g:3638:1: ( 'format' ) |
| { |
| // InternalGridSource.g:3638:1: ( 'format' ) |
| // InternalGridSource.g:3639:2: 'format' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getFormatKeyword_6_1()); |
| } |
| match(input,40,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getFormatKeyword_6_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group_6__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group_6__2" |
| // InternalGridSource.g:3648:1: rule__PropertyPriceStyle__Group_6__2 : rule__PropertyPriceStyle__Group_6__2__Impl rule__PropertyPriceStyle__Group_6__3 ; |
| public final void rule__PropertyPriceStyle__Group_6__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3652:1: ( rule__PropertyPriceStyle__Group_6__2__Impl rule__PropertyPriceStyle__Group_6__3 ) |
| // InternalGridSource.g:3653:2: rule__PropertyPriceStyle__Group_6__2__Impl rule__PropertyPriceStyle__Group_6__3 |
| { |
| pushFollow(FOLLOW_38); |
| rule__PropertyPriceStyle__Group_6__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group_6__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group_6__2" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group_6__2__Impl" |
| // InternalGridSource.g:3660:1: rule__PropertyPriceStyle__Group_6__2__Impl : ( ( rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2 ) ) ; |
| public final void rule__PropertyPriceStyle__Group_6__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3664:1: ( ( ( rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2 ) ) ) |
| // InternalGridSource.g:3665:1: ( ( rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2 ) ) |
| { |
| // InternalGridSource.g:3665:1: ( ( rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2 ) ) |
| // InternalGridSource.g:3666:2: ( rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getValueNumberFormatAssignment_6_2()); |
| } |
| // InternalGridSource.g:3667:2: ( rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2 ) |
| // InternalGridSource.g:3667:3: rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getValueNumberFormatAssignment_6_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group_6__2__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group_6__3" |
| // InternalGridSource.g:3675:1: rule__PropertyPriceStyle__Group_6__3 : rule__PropertyPriceStyle__Group_6__3__Impl ; |
| public final void rule__PropertyPriceStyle__Group_6__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3679:1: ( rule__PropertyPriceStyle__Group_6__3__Impl ) |
| // InternalGridSource.g:3680:2: rule__PropertyPriceStyle__Group_6__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyPriceStyle__Group_6__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group_6__3" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__Group_6__3__Impl" |
| // InternalGridSource.g:3686:1: rule__PropertyPriceStyle__Group_6__3__Impl : ( ')' ) ; |
| public final void rule__PropertyPriceStyle__Group_6__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3690:1: ( ( ')' ) ) |
| // InternalGridSource.g:3691:1: ( ')' ) |
| { |
| // InternalGridSource.g:3691:1: ( ')' ) |
| // InternalGridSource.g:3692:2: ')' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getRightParenthesisKeyword_6_3()); |
| } |
| match(input,51,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getRightParenthesisKeyword_6_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__Group_6__3__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyTextStyle__Group__0" |
| // InternalGridSource.g:3702:1: rule__PropertyTextStyle__Group__0 : rule__PropertyTextStyle__Group__0__Impl rule__PropertyTextStyle__Group__1 ; |
| public final void rule__PropertyTextStyle__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3706:1: ( rule__PropertyTextStyle__Group__0__Impl rule__PropertyTextStyle__Group__1 ) |
| // InternalGridSource.g:3707:2: rule__PropertyTextStyle__Group__0__Impl rule__PropertyTextStyle__Group__1 |
| { |
| pushFollow(FOLLOW_41); |
| rule__PropertyTextStyle__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyTextStyle__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyTextStyle__Group__0" |
| |
| |
| // $ANTLR start "rule__PropertyTextStyle__Group__0__Impl" |
| // InternalGridSource.g:3714:1: rule__PropertyTextStyle__Group__0__Impl : ( () ) ; |
| public final void rule__PropertyTextStyle__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3718:1: ( ( () ) ) |
| // InternalGridSource.g:3719:1: ( () ) |
| { |
| // InternalGridSource.g:3719:1: ( () ) |
| // InternalGridSource.g:3720:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyTextStyleAccess().getCxGridPropTextStyleAction_0()); |
| } |
| // InternalGridSource.g:3721:2: () |
| // InternalGridSource.g:3721:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyTextStyleAccess().getCxGridPropTextStyleAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyTextStyle__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyTextStyle__Group__1" |
| // InternalGridSource.g:3729:1: rule__PropertyTextStyle__Group__1 : rule__PropertyTextStyle__Group__1__Impl ; |
| public final void rule__PropertyTextStyle__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3733:1: ( rule__PropertyTextStyle__Group__1__Impl ) |
| // InternalGridSource.g:3734:2: rule__PropertyTextStyle__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyTextStyle__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyTextStyle__Group__1" |
| |
| |
| // $ANTLR start "rule__PropertyTextStyle__Group__1__Impl" |
| // InternalGridSource.g:3740:1: rule__PropertyTextStyle__Group__1__Impl : ( 'textStyle' ) ; |
| public final void rule__PropertyTextStyle__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3744:1: ( ( 'textStyle' ) ) |
| // InternalGridSource.g:3745:1: ( 'textStyle' ) |
| { |
| // InternalGridSource.g:3745:1: ( 'textStyle' ) |
| // InternalGridSource.g:3746:2: 'textStyle' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyTextStyleAccess().getTextStyleKeyword_1()); |
| } |
| match(input,54,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyTextStyleAccess().getTextStyleKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyTextStyle__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__0" |
| // InternalGridSource.g:3756:1: rule__PropertyImageStyle__Group__0 : rule__PropertyImageStyle__Group__0__Impl rule__PropertyImageStyle__Group__1 ; |
| public final void rule__PropertyImageStyle__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3760:1: ( rule__PropertyImageStyle__Group__0__Impl rule__PropertyImageStyle__Group__1 ) |
| // InternalGridSource.g:3761:2: rule__PropertyImageStyle__Group__0__Impl rule__PropertyImageStyle__Group__1 |
| { |
| pushFollow(FOLLOW_42); |
| rule__PropertyImageStyle__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyImageStyle__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__0" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__0__Impl" |
| // InternalGridSource.g:3768:1: rule__PropertyImageStyle__Group__0__Impl : ( () ) ; |
| public final void rule__PropertyImageStyle__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3772:1: ( ( () ) ) |
| // InternalGridSource.g:3773:1: ( () ) |
| { |
| // InternalGridSource.g:3773:1: ( () ) |
| // InternalGridSource.g:3774:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleAccess().getCxGridPropImageStyleAction_0()); |
| } |
| // InternalGridSource.g:3775:2: () |
| // InternalGridSource.g:3775:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleAccess().getCxGridPropImageStyleAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__1" |
| // InternalGridSource.g:3783:1: rule__PropertyImageStyle__Group__1 : rule__PropertyImageStyle__Group__1__Impl rule__PropertyImageStyle__Group__2 ; |
| public final void rule__PropertyImageStyle__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3787:1: ( rule__PropertyImageStyle__Group__1__Impl rule__PropertyImageStyle__Group__2 ) |
| // InternalGridSource.g:3788:2: rule__PropertyImageStyle__Group__1__Impl rule__PropertyImageStyle__Group__2 |
| { |
| pushFollow(FOLLOW_43); |
| rule__PropertyImageStyle__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyImageStyle__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__1" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__1__Impl" |
| // InternalGridSource.g:3795:1: rule__PropertyImageStyle__Group__1__Impl : ( 'imageStyle' ) ; |
| public final void rule__PropertyImageStyle__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3799:1: ( ( 'imageStyle' ) ) |
| // InternalGridSource.g:3800:1: ( 'imageStyle' ) |
| { |
| // InternalGridSource.g:3800:1: ( 'imageStyle' ) |
| // InternalGridSource.g:3801:2: 'imageStyle' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleAccess().getImageStyleKeyword_1()); |
| } |
| match(input,55,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleAccess().getImageStyleKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__2" |
| // InternalGridSource.g:3810:1: rule__PropertyImageStyle__Group__2 : rule__PropertyImageStyle__Group__2__Impl rule__PropertyImageStyle__Group__3 ; |
| public final void rule__PropertyImageStyle__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3814:1: ( rule__PropertyImageStyle__Group__2__Impl rule__PropertyImageStyle__Group__3 ) |
| // InternalGridSource.g:3815:2: rule__PropertyImageStyle__Group__2__Impl rule__PropertyImageStyle__Group__3 |
| { |
| pushFollow(FOLLOW_43); |
| rule__PropertyImageStyle__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyImageStyle__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__2" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__2__Impl" |
| // InternalGridSource.g:3822:1: rule__PropertyImageStyle__Group__2__Impl : ( ( rule__PropertyImageStyle__Group_2__0 )? ) ; |
| public final void rule__PropertyImageStyle__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3826:1: ( ( ( rule__PropertyImageStyle__Group_2__0 )? ) ) |
| // InternalGridSource.g:3827:1: ( ( rule__PropertyImageStyle__Group_2__0 )? ) |
| { |
| // InternalGridSource.g:3827:1: ( ( rule__PropertyImageStyle__Group_2__0 )? ) |
| // InternalGridSource.g:3828:2: ( rule__PropertyImageStyle__Group_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleAccess().getGroup_2()); |
| } |
| // InternalGridSource.g:3829:2: ( rule__PropertyImageStyle__Group_2__0 )? |
| int alt20=2; |
| int LA20_0 = input.LA(1); |
| |
| if ( (LA20_0==36) ) { |
| alt20=1; |
| } |
| switch (alt20) { |
| case 1 : |
| // InternalGridSource.g:3829:3: rule__PropertyImageStyle__Group_2__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyImageStyle__Group_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleAccess().getGroup_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__3" |
| // InternalGridSource.g:3837:1: rule__PropertyImageStyle__Group__3 : rule__PropertyImageStyle__Group__3__Impl rule__PropertyImageStyle__Group__4 ; |
| public final void rule__PropertyImageStyle__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3841:1: ( rule__PropertyImageStyle__Group__3__Impl rule__PropertyImageStyle__Group__4 ) |
| // InternalGridSource.g:3842:2: rule__PropertyImageStyle__Group__3__Impl rule__PropertyImageStyle__Group__4 |
| { |
| pushFollow(FOLLOW_44); |
| rule__PropertyImageStyle__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyImageStyle__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__3" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__3__Impl" |
| // InternalGridSource.g:3849:1: rule__PropertyImageStyle__Group__3__Impl : ( '{' ) ; |
| public final void rule__PropertyImageStyle__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3853:1: ( ( '{' ) ) |
| // InternalGridSource.g:3854:1: ( '{' ) |
| { |
| // InternalGridSource.g:3854:1: ( '{' ) |
| // InternalGridSource.g:3855:2: '{' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleAccess().getLeftCurlyBracketKeyword_3()); |
| } |
| match(input,23,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleAccess().getLeftCurlyBracketKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__4" |
| // InternalGridSource.g:3864:1: rule__PropertyImageStyle__Group__4 : rule__PropertyImageStyle__Group__4__Impl rule__PropertyImageStyle__Group__5 ; |
| public final void rule__PropertyImageStyle__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3868:1: ( rule__PropertyImageStyle__Group__4__Impl rule__PropertyImageStyle__Group__5 ) |
| // InternalGridSource.g:3869:2: rule__PropertyImageStyle__Group__4__Impl rule__PropertyImageStyle__Group__5 |
| { |
| pushFollow(FOLLOW_44); |
| rule__PropertyImageStyle__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyImageStyle__Group__5(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__4" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__4__Impl" |
| // InternalGridSource.g:3876:1: rule__PropertyImageStyle__Group__4__Impl : ( ( rule__PropertyImageStyle__ConfigsAssignment_4 )* ) ; |
| public final void rule__PropertyImageStyle__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3880:1: ( ( ( rule__PropertyImageStyle__ConfigsAssignment_4 )* ) ) |
| // InternalGridSource.g:3881:1: ( ( rule__PropertyImageStyle__ConfigsAssignment_4 )* ) |
| { |
| // InternalGridSource.g:3881:1: ( ( rule__PropertyImageStyle__ConfigsAssignment_4 )* ) |
| // InternalGridSource.g:3882:2: ( rule__PropertyImageStyle__ConfigsAssignment_4 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleAccess().getConfigsAssignment_4()); |
| } |
| // InternalGridSource.g:3883:2: ( rule__PropertyImageStyle__ConfigsAssignment_4 )* |
| loop21: |
| do { |
| int alt21=2; |
| int LA21_0 = input.LA(1); |
| |
| if ( (LA21_0==56||LA21_0==58) ) { |
| alt21=1; |
| } |
| |
| |
| switch (alt21) { |
| case 1 : |
| // InternalGridSource.g:3883:3: rule__PropertyImageStyle__ConfigsAssignment_4 |
| { |
| pushFollow(FOLLOW_45); |
| rule__PropertyImageStyle__ConfigsAssignment_4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop21; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleAccess().getConfigsAssignment_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__5" |
| // InternalGridSource.g:3891:1: rule__PropertyImageStyle__Group__5 : rule__PropertyImageStyle__Group__5__Impl ; |
| public final void rule__PropertyImageStyle__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3895:1: ( rule__PropertyImageStyle__Group__5__Impl ) |
| // InternalGridSource.g:3896:2: rule__PropertyImageStyle__Group__5__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyImageStyle__Group__5__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__5" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group__5__Impl" |
| // InternalGridSource.g:3902:1: rule__PropertyImageStyle__Group__5__Impl : ( '}' ) ; |
| public final void rule__PropertyImageStyle__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3906:1: ( ( '}' ) ) |
| // InternalGridSource.g:3907:1: ( '}' ) |
| { |
| // InternalGridSource.g:3907:1: ( '}' ) |
| // InternalGridSource.g:3908:2: '}' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleAccess().getRightCurlyBracketKeyword_5()); |
| } |
| match(input,25,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleAccess().getRightCurlyBracketKeyword_5()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group_2__0" |
| // InternalGridSource.g:3918:1: rule__PropertyImageStyle__Group_2__0 : rule__PropertyImageStyle__Group_2__0__Impl rule__PropertyImageStyle__Group_2__1 ; |
| public final void rule__PropertyImageStyle__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3922:1: ( rule__PropertyImageStyle__Group_2__0__Impl rule__PropertyImageStyle__Group_2__1 ) |
| // InternalGridSource.g:3923:2: rule__PropertyImageStyle__Group_2__0__Impl rule__PropertyImageStyle__Group_2__1 |
| { |
| pushFollow(FOLLOW_24); |
| rule__PropertyImageStyle__Group_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__PropertyImageStyle__Group_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group_2__0" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group_2__0__Impl" |
| // InternalGridSource.g:3930:1: rule__PropertyImageStyle__Group_2__0__Impl : ( 'eventTopic' ) ; |
| public final void rule__PropertyImageStyle__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3934:1: ( ( 'eventTopic' ) ) |
| // InternalGridSource.g:3935:1: ( 'eventTopic' ) |
| { |
| // InternalGridSource.g:3935:1: ( 'eventTopic' ) |
| // InternalGridSource.g:3936:2: 'eventTopic' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleAccess().getEventTopicKeyword_2_0()); |
| } |
| match(input,36,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleAccess().getEventTopicKeyword_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group_2__1" |
| // InternalGridSource.g:3945:1: rule__PropertyImageStyle__Group_2__1 : rule__PropertyImageStyle__Group_2__1__Impl ; |
| public final void rule__PropertyImageStyle__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3949:1: ( rule__PropertyImageStyle__Group_2__1__Impl ) |
| // InternalGridSource.g:3950:2: rule__PropertyImageStyle__Group_2__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyImageStyle__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__PropertyImageStyle__Group_2__1" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__Group_2__1__Impl" |
| // InternalGridSource.g:3956:1: rule__PropertyImageStyle__Group_2__1__Impl : ( ( rule__PropertyImageStyle__EventTopicAssignment_2_1 ) ) ; |
| public final void rule__PropertyImageStyle__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3960:1: ( ( ( rule__PropertyImageStyle__EventTopicAssignment_2_1 ) ) ) |
| // InternalGridSource.g:3961:1: ( ( rule__PropertyImageStyle__EventTopicAssignment_2_1 ) ) |
| { |
| // InternalGridSource.g:3961:1: ( ( rule__PropertyImageStyle__EventTopicAssignment_2_1 ) ) |
| // InternalGridSource.g:3962:2: ( rule__PropertyImageStyle__EventTopicAssignment_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleAccess().getEventTopicAssignment_2_1()); |
| } |
| // InternalGridSource.g:3963:2: ( rule__PropertyImageStyle__EventTopicAssignment_2_1 ) |
| // InternalGridSource.g:3963:3: rule__PropertyImageStyle__EventTopicAssignment_2_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__PropertyImageStyle__EventTopicAssignment_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleAccess().getEventTopicAssignment_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__QualifiedName__Group__0" |
| // InternalGridSource.g:3972:1: rule__QualifiedName__Group__0 : rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ; |
| public final void rule__QualifiedName__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3976:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ) |
| // InternalGridSource.g:3977:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 |
| { |
| pushFollow(FOLLOW_21); |
| rule__QualifiedName__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__QualifiedName__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedName__Group__0" |
| |
| |
| // $ANTLR start "rule__QualifiedName__Group__0__Impl" |
| // InternalGridSource.g:3984:1: rule__QualifiedName__Group__0__Impl : ( ruleValidID ) ; |
| public final void rule__QualifiedName__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:3988:1: ( ( ruleValidID ) ) |
| // InternalGridSource.g:3989:1: ( ruleValidID ) |
| { |
| // InternalGridSource.g:3989:1: ( ruleValidID ) |
| // InternalGridSource.g:3990:2: ruleValidID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleValidID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedName__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__QualifiedName__Group__1" |
| // InternalGridSource.g:3999:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ; |
| public final void rule__QualifiedName__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4003:1: ( rule__QualifiedName__Group__1__Impl ) |
| // InternalGridSource.g:4004:2: rule__QualifiedName__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__QualifiedName__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedName__Group__1" |
| |
| |
| // $ANTLR start "rule__QualifiedName__Group__1__Impl" |
| // InternalGridSource.g:4010:1: rule__QualifiedName__Group__1__Impl : ( ( rule__QualifiedName__Group_1__0 )* ) ; |
| public final void rule__QualifiedName__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4014:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) ) |
| // InternalGridSource.g:4015:1: ( ( rule__QualifiedName__Group_1__0 )* ) |
| { |
| // InternalGridSource.g:4015:1: ( ( rule__QualifiedName__Group_1__0 )* ) |
| // InternalGridSource.g:4016:2: ( rule__QualifiedName__Group_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameAccess().getGroup_1()); |
| } |
| // InternalGridSource.g:4017:2: ( rule__QualifiedName__Group_1__0 )* |
| loop22: |
| do { |
| int alt22=2; |
| int LA22_0 = input.LA(1); |
| |
| if ( (LA22_0==34) ) { |
| int LA22_2 = input.LA(2); |
| |
| if ( (LA22_2==RULE_ID) ) { |
| alt22=1; |
| } |
| |
| |
| } |
| |
| |
| switch (alt22) { |
| case 1 : |
| // InternalGridSource.g:4017:3: rule__QualifiedName__Group_1__0 |
| { |
| pushFollow(FOLLOW_46); |
| rule__QualifiedName__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop22; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedName__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__QualifiedName__Group_1__0" |
| // InternalGridSource.g:4026:1: rule__QualifiedName__Group_1__0 : rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ; |
| public final void rule__QualifiedName__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4030:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ) |
| // InternalGridSource.g:4031:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 |
| { |
| pushFollow(FOLLOW_4); |
| rule__QualifiedName__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__QualifiedName__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedName__Group_1__0" |
| |
| |
| // $ANTLR start "rule__QualifiedName__Group_1__0__Impl" |
| // InternalGridSource.g:4038:1: rule__QualifiedName__Group_1__0__Impl : ( ( '.' ) ) ; |
| public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4042:1: ( ( ( '.' ) ) ) |
| // InternalGridSource.g:4043:1: ( ( '.' ) ) |
| { |
| // InternalGridSource.g:4043:1: ( ( '.' ) ) |
| // InternalGridSource.g:4044:2: ( '.' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); |
| } |
| // InternalGridSource.g:4045:2: ( '.' ) |
| // InternalGridSource.g:4045:3: '.' |
| { |
| match(input,34,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedName__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__QualifiedName__Group_1__1" |
| // InternalGridSource.g:4053:1: rule__QualifiedName__Group_1__1 : rule__QualifiedName__Group_1__1__Impl ; |
| public final void rule__QualifiedName__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4057:1: ( rule__QualifiedName__Group_1__1__Impl ) |
| // InternalGridSource.g:4058:2: rule__QualifiedName__Group_1__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__QualifiedName__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__QualifiedName__Group_1__1" |
| |
| |
| // $ANTLR start "rule__QualifiedName__Group_1__1__Impl" |
| // InternalGridSource.g:4064:1: rule__QualifiedName__Group_1__1__Impl : ( ruleValidID ) ; |
| public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4068:1: ( ( ruleValidID ) ) |
| // InternalGridSource.g:4069:1: ( ruleValidID ) |
| { |
| // InternalGridSource.g:4069:1: ( ruleValidID ) |
| // InternalGridSource.g:4070:2: ruleValidID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleValidID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedName__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__Group__0" |
| // InternalGridSource.g:4080:1: rule__NumericToResourceStyleConfig__Group__0 : rule__NumericToResourceStyleConfig__Group__0__Impl rule__NumericToResourceStyleConfig__Group__1 ; |
| public final void rule__NumericToResourceStyleConfig__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4084:1: ( rule__NumericToResourceStyleConfig__Group__0__Impl rule__NumericToResourceStyleConfig__Group__1 ) |
| // InternalGridSource.g:4085:2: rule__NumericToResourceStyleConfig__Group__0__Impl rule__NumericToResourceStyleConfig__Group__1 |
| { |
| pushFollow(FOLLOW_47); |
| rule__NumericToResourceStyleConfig__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__NumericToResourceStyleConfig__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__Group__0" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__Group__0__Impl" |
| // InternalGridSource.g:4092:1: rule__NumericToResourceStyleConfig__Group__0__Impl : ( 'number' ) ; |
| public final void rule__NumericToResourceStyleConfig__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4096:1: ( ( 'number' ) ) |
| // InternalGridSource.g:4097:1: ( 'number' ) |
| { |
| // InternalGridSource.g:4097:1: ( 'number' ) |
| // InternalGridSource.g:4098:2: 'number' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumericToResourceStyleConfigAccess().getNumberKeyword_0()); |
| } |
| match(input,56,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumericToResourceStyleConfigAccess().getNumberKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__Group__1" |
| // InternalGridSource.g:4107:1: rule__NumericToResourceStyleConfig__Group__1 : rule__NumericToResourceStyleConfig__Group__1__Impl rule__NumericToResourceStyleConfig__Group__2 ; |
| public final void rule__NumericToResourceStyleConfig__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4111:1: ( rule__NumericToResourceStyleConfig__Group__1__Impl rule__NumericToResourceStyleConfig__Group__2 ) |
| // InternalGridSource.g:4112:2: rule__NumericToResourceStyleConfig__Group__1__Impl rule__NumericToResourceStyleConfig__Group__2 |
| { |
| pushFollow(FOLLOW_32); |
| rule__NumericToResourceStyleConfig__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__NumericToResourceStyleConfig__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__Group__1" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__Group__1__Impl" |
| // InternalGridSource.g:4119:1: rule__NumericToResourceStyleConfig__Group__1__Impl : ( ( rule__NumericToResourceStyleConfig__CompareAssignment_1 ) ) ; |
| public final void rule__NumericToResourceStyleConfig__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4123:1: ( ( ( rule__NumericToResourceStyleConfig__CompareAssignment_1 ) ) ) |
| // InternalGridSource.g:4124:1: ( ( rule__NumericToResourceStyleConfig__CompareAssignment_1 ) ) |
| { |
| // InternalGridSource.g:4124:1: ( ( rule__NumericToResourceStyleConfig__CompareAssignment_1 ) ) |
| // InternalGridSource.g:4125:2: ( rule__NumericToResourceStyleConfig__CompareAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumericToResourceStyleConfigAccess().getCompareAssignment_1()); |
| } |
| // InternalGridSource.g:4126:2: ( rule__NumericToResourceStyleConfig__CompareAssignment_1 ) |
| // InternalGridSource.g:4126:3: rule__NumericToResourceStyleConfig__CompareAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__NumericToResourceStyleConfig__CompareAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumericToResourceStyleConfigAccess().getCompareAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__Group__2" |
| // InternalGridSource.g:4134:1: rule__NumericToResourceStyleConfig__Group__2 : rule__NumericToResourceStyleConfig__Group__2__Impl rule__NumericToResourceStyleConfig__Group__3 ; |
| public final void rule__NumericToResourceStyleConfig__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4138:1: ( rule__NumericToResourceStyleConfig__Group__2__Impl rule__NumericToResourceStyleConfig__Group__3 ) |
| // InternalGridSource.g:4139:2: rule__NumericToResourceStyleConfig__Group__2__Impl rule__NumericToResourceStyleConfig__Group__3 |
| { |
| pushFollow(FOLLOW_48); |
| rule__NumericToResourceStyleConfig__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__NumericToResourceStyleConfig__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__Group__2" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__Group__2__Impl" |
| // InternalGridSource.g:4146:1: rule__NumericToResourceStyleConfig__Group__2__Impl : ( ( rule__NumericToResourceStyleConfig__ValueAssignment_2 ) ) ; |
| public final void rule__NumericToResourceStyleConfig__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4150:1: ( ( ( rule__NumericToResourceStyleConfig__ValueAssignment_2 ) ) ) |
| // InternalGridSource.g:4151:1: ( ( rule__NumericToResourceStyleConfig__ValueAssignment_2 ) ) |
| { |
| // InternalGridSource.g:4151:1: ( ( rule__NumericToResourceStyleConfig__ValueAssignment_2 ) ) |
| // InternalGridSource.g:4152:2: ( rule__NumericToResourceStyleConfig__ValueAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumericToResourceStyleConfigAccess().getValueAssignment_2()); |
| } |
| // InternalGridSource.g:4153:2: ( rule__NumericToResourceStyleConfig__ValueAssignment_2 ) |
| // InternalGridSource.g:4153:3: rule__NumericToResourceStyleConfig__ValueAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__NumericToResourceStyleConfig__ValueAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumericToResourceStyleConfigAccess().getValueAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__Group__3" |
| // InternalGridSource.g:4161:1: rule__NumericToResourceStyleConfig__Group__3 : rule__NumericToResourceStyleConfig__Group__3__Impl rule__NumericToResourceStyleConfig__Group__4 ; |
| public final void rule__NumericToResourceStyleConfig__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4165:1: ( rule__NumericToResourceStyleConfig__Group__3__Impl rule__NumericToResourceStyleConfig__Group__4 ) |
| // InternalGridSource.g:4166:2: rule__NumericToResourceStyleConfig__Group__3__Impl rule__NumericToResourceStyleConfig__Group__4 |
| { |
| pushFollow(FOLLOW_49); |
| rule__NumericToResourceStyleConfig__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__NumericToResourceStyleConfig__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__Group__3" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__Group__3__Impl" |
| // InternalGridSource.g:4173:1: rule__NumericToResourceStyleConfig__Group__3__Impl : ( 'then' ) ; |
| public final void rule__NumericToResourceStyleConfig__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4177:1: ( ( 'then' ) ) |
| // InternalGridSource.g:4178:1: ( 'then' ) |
| { |
| // InternalGridSource.g:4178:1: ( 'then' ) |
| // InternalGridSource.g:4179:2: 'then' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumericToResourceStyleConfigAccess().getThenKeyword_3()); |
| } |
| match(input,57,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumericToResourceStyleConfigAccess().getThenKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__Group__4" |
| // InternalGridSource.g:4188:1: rule__NumericToResourceStyleConfig__Group__4 : rule__NumericToResourceStyleConfig__Group__4__Impl ; |
| public final void rule__NumericToResourceStyleConfig__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4192:1: ( rule__NumericToResourceStyleConfig__Group__4__Impl ) |
| // InternalGridSource.g:4193:2: rule__NumericToResourceStyleConfig__Group__4__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__NumericToResourceStyleConfig__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__Group__4" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__Group__4__Impl" |
| // InternalGridSource.g:4199:1: rule__NumericToResourceStyleConfig__Group__4__Impl : ( ( rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4 ) ) ; |
| public final void rule__NumericToResourceStyleConfig__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4203:1: ( ( ( rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4 ) ) ) |
| // InternalGridSource.g:4204:1: ( ( rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4 ) ) |
| { |
| // InternalGridSource.g:4204:1: ( ( rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4 ) ) |
| // InternalGridSource.g:4205:2: ( rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumericToResourceStyleConfigAccess().getResourceThemePathAssignment_4()); |
| } |
| // InternalGridSource.g:4206:2: ( rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4 ) |
| // InternalGridSource.g:4206:3: rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4 |
| { |
| pushFollow(FOLLOW_2); |
| rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumericToResourceStyleConfigAccess().getResourceThemePathAssignment_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__Group__0" |
| // InternalGridSource.g:4215:1: rule__StringToResourceStyleConfig__Group__0 : rule__StringToResourceStyleConfig__Group__0__Impl rule__StringToResourceStyleConfig__Group__1 ; |
| public final void rule__StringToResourceStyleConfig__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4219:1: ( rule__StringToResourceStyleConfig__Group__0__Impl rule__StringToResourceStyleConfig__Group__1 ) |
| // InternalGridSource.g:4220:2: rule__StringToResourceStyleConfig__Group__0__Impl rule__StringToResourceStyleConfig__Group__1 |
| { |
| pushFollow(FOLLOW_47); |
| rule__StringToResourceStyleConfig__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__StringToResourceStyleConfig__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__Group__0" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__Group__0__Impl" |
| // InternalGridSource.g:4227:1: rule__StringToResourceStyleConfig__Group__0__Impl : ( 'string' ) ; |
| public final void rule__StringToResourceStyleConfig__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4231:1: ( ( 'string' ) ) |
| // InternalGridSource.g:4232:1: ( 'string' ) |
| { |
| // InternalGridSource.g:4232:1: ( 'string' ) |
| // InternalGridSource.g:4233:2: 'string' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringToResourceStyleConfigAccess().getStringKeyword_0()); |
| } |
| match(input,58,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringToResourceStyleConfigAccess().getStringKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__Group__1" |
| // InternalGridSource.g:4242:1: rule__StringToResourceStyleConfig__Group__1 : rule__StringToResourceStyleConfig__Group__1__Impl rule__StringToResourceStyleConfig__Group__2 ; |
| public final void rule__StringToResourceStyleConfig__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4246:1: ( rule__StringToResourceStyleConfig__Group__1__Impl rule__StringToResourceStyleConfig__Group__2 ) |
| // InternalGridSource.g:4247:2: rule__StringToResourceStyleConfig__Group__1__Impl rule__StringToResourceStyleConfig__Group__2 |
| { |
| pushFollow(FOLLOW_24); |
| rule__StringToResourceStyleConfig__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__StringToResourceStyleConfig__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__Group__1" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__Group__1__Impl" |
| // InternalGridSource.g:4254:1: rule__StringToResourceStyleConfig__Group__1__Impl : ( ( rule__StringToResourceStyleConfig__CompareAssignment_1 ) ) ; |
| public final void rule__StringToResourceStyleConfig__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4258:1: ( ( ( rule__StringToResourceStyleConfig__CompareAssignment_1 ) ) ) |
| // InternalGridSource.g:4259:1: ( ( rule__StringToResourceStyleConfig__CompareAssignment_1 ) ) |
| { |
| // InternalGridSource.g:4259:1: ( ( rule__StringToResourceStyleConfig__CompareAssignment_1 ) ) |
| // InternalGridSource.g:4260:2: ( rule__StringToResourceStyleConfig__CompareAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringToResourceStyleConfigAccess().getCompareAssignment_1()); |
| } |
| // InternalGridSource.g:4261:2: ( rule__StringToResourceStyleConfig__CompareAssignment_1 ) |
| // InternalGridSource.g:4261:3: rule__StringToResourceStyleConfig__CompareAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StringToResourceStyleConfig__CompareAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringToResourceStyleConfigAccess().getCompareAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__Group__2" |
| // InternalGridSource.g:4269:1: rule__StringToResourceStyleConfig__Group__2 : rule__StringToResourceStyleConfig__Group__2__Impl rule__StringToResourceStyleConfig__Group__3 ; |
| public final void rule__StringToResourceStyleConfig__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4273:1: ( rule__StringToResourceStyleConfig__Group__2__Impl rule__StringToResourceStyleConfig__Group__3 ) |
| // InternalGridSource.g:4274:2: rule__StringToResourceStyleConfig__Group__2__Impl rule__StringToResourceStyleConfig__Group__3 |
| { |
| pushFollow(FOLLOW_48); |
| rule__StringToResourceStyleConfig__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__StringToResourceStyleConfig__Group__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__Group__2" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__Group__2__Impl" |
| // InternalGridSource.g:4281:1: rule__StringToResourceStyleConfig__Group__2__Impl : ( ( rule__StringToResourceStyleConfig__ValueAssignment_2 ) ) ; |
| public final void rule__StringToResourceStyleConfig__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4285:1: ( ( ( rule__StringToResourceStyleConfig__ValueAssignment_2 ) ) ) |
| // InternalGridSource.g:4286:1: ( ( rule__StringToResourceStyleConfig__ValueAssignment_2 ) ) |
| { |
| // InternalGridSource.g:4286:1: ( ( rule__StringToResourceStyleConfig__ValueAssignment_2 ) ) |
| // InternalGridSource.g:4287:2: ( rule__StringToResourceStyleConfig__ValueAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringToResourceStyleConfigAccess().getValueAssignment_2()); |
| } |
| // InternalGridSource.g:4288:2: ( rule__StringToResourceStyleConfig__ValueAssignment_2 ) |
| // InternalGridSource.g:4288:3: rule__StringToResourceStyleConfig__ValueAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StringToResourceStyleConfig__ValueAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringToResourceStyleConfigAccess().getValueAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__Group__3" |
| // InternalGridSource.g:4296:1: rule__StringToResourceStyleConfig__Group__3 : rule__StringToResourceStyleConfig__Group__3__Impl rule__StringToResourceStyleConfig__Group__4 ; |
| public final void rule__StringToResourceStyleConfig__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4300:1: ( rule__StringToResourceStyleConfig__Group__3__Impl rule__StringToResourceStyleConfig__Group__4 ) |
| // InternalGridSource.g:4301:2: rule__StringToResourceStyleConfig__Group__3__Impl rule__StringToResourceStyleConfig__Group__4 |
| { |
| pushFollow(FOLLOW_49); |
| rule__StringToResourceStyleConfig__Group__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__StringToResourceStyleConfig__Group__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__Group__3" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__Group__3__Impl" |
| // InternalGridSource.g:4308:1: rule__StringToResourceStyleConfig__Group__3__Impl : ( 'then' ) ; |
| public final void rule__StringToResourceStyleConfig__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4312:1: ( ( 'then' ) ) |
| // InternalGridSource.g:4313:1: ( 'then' ) |
| { |
| // InternalGridSource.g:4313:1: ( 'then' ) |
| // InternalGridSource.g:4314:2: 'then' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringToResourceStyleConfigAccess().getThenKeyword_3()); |
| } |
| match(input,57,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringToResourceStyleConfigAccess().getThenKeyword_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__Group__4" |
| // InternalGridSource.g:4323:1: rule__StringToResourceStyleConfig__Group__4 : rule__StringToResourceStyleConfig__Group__4__Impl ; |
| public final void rule__StringToResourceStyleConfig__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4327:1: ( rule__StringToResourceStyleConfig__Group__4__Impl ) |
| // InternalGridSource.g:4328:2: rule__StringToResourceStyleConfig__Group__4__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__StringToResourceStyleConfig__Group__4__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__Group__4" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__Group__4__Impl" |
| // InternalGridSource.g:4334:1: rule__StringToResourceStyleConfig__Group__4__Impl : ( ( rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4 ) ) ; |
| public final void rule__StringToResourceStyleConfig__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4338:1: ( ( ( rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4 ) ) ) |
| // InternalGridSource.g:4339:1: ( ( rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4 ) ) |
| { |
| // InternalGridSource.g:4339:1: ( ( rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4 ) ) |
| // InternalGridSource.g:4340:2: ( rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringToResourceStyleConfigAccess().getResourceThemePathAssignment_4()); |
| } |
| // InternalGridSource.g:4341:2: ( rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4 ) |
| // InternalGridSource.g:4341:3: rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringToResourceStyleConfigAccess().getResourceThemePathAssignment_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__LInt__Group__0" |
| // InternalGridSource.g:4350:1: rule__LInt__Group__0 : rule__LInt__Group__0__Impl rule__LInt__Group__1 ; |
| public final void rule__LInt__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4354:1: ( rule__LInt__Group__0__Impl rule__LInt__Group__1 ) |
| // InternalGridSource.g:4355:2: rule__LInt__Group__0__Impl rule__LInt__Group__1 |
| { |
| pushFollow(FOLLOW_32); |
| rule__LInt__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__LInt__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LInt__Group__0" |
| |
| |
| // $ANTLR start "rule__LInt__Group__0__Impl" |
| // InternalGridSource.g:4362:1: rule__LInt__Group__0__Impl : ( ( rule__LInt__Alternatives_0 )? ) ; |
| public final void rule__LInt__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4366:1: ( ( ( rule__LInt__Alternatives_0 )? ) ) |
| // InternalGridSource.g:4367:1: ( ( rule__LInt__Alternatives_0 )? ) |
| { |
| // InternalGridSource.g:4367:1: ( ( rule__LInt__Alternatives_0 )? ) |
| // InternalGridSource.g:4368:2: ( rule__LInt__Alternatives_0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLIntAccess().getAlternatives_0()); |
| } |
| // InternalGridSource.g:4369:2: ( rule__LInt__Alternatives_0 )? |
| int alt23=2; |
| int LA23_0 = input.LA(1); |
| |
| if ( ((LA23_0>=13 && LA23_0<=14)) ) { |
| alt23=1; |
| } |
| switch (alt23) { |
| case 1 : |
| // InternalGridSource.g:4369:3: rule__LInt__Alternatives_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__LInt__Alternatives_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLIntAccess().getAlternatives_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LInt__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LInt__Group__1" |
| // InternalGridSource.g:4377:1: rule__LInt__Group__1 : rule__LInt__Group__1__Impl ; |
| public final void rule__LInt__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4381:1: ( rule__LInt__Group__1__Impl ) |
| // InternalGridSource.g:4382:2: rule__LInt__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__LInt__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LInt__Group__1" |
| |
| |
| // $ANTLR start "rule__LInt__Group__1__Impl" |
| // InternalGridSource.g:4388:1: rule__LInt__Group__1__Impl : ( RULE_INT ) ; |
| public final void rule__LInt__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4392:1: ( ( RULE_INT ) ) |
| // InternalGridSource.g:4393:1: ( RULE_INT ) |
| { |
| // InternalGridSource.g:4393:1: ( RULE_INT ) |
| // InternalGridSource.g:4394:2: RULE_INT |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLIntAccess().getINTTerminalRuleCall_1()); |
| } |
| match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLIntAccess().getINTTerminalRuleCall_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LInt__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LDouble__Group__0" |
| // InternalGridSource.g:4404:1: rule__LDouble__Group__0 : rule__LDouble__Group__0__Impl rule__LDouble__Group__1 ; |
| public final void rule__LDouble__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4408:1: ( rule__LDouble__Group__0__Impl rule__LDouble__Group__1 ) |
| // InternalGridSource.g:4409:2: rule__LDouble__Group__0__Impl rule__LDouble__Group__1 |
| { |
| pushFollow(FOLLOW_21); |
| rule__LDouble__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__LDouble__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LDouble__Group__0" |
| |
| |
| // $ANTLR start "rule__LDouble__Group__0__Impl" |
| // InternalGridSource.g:4416:1: rule__LDouble__Group__0__Impl : ( ruleLInt ) ; |
| public final void rule__LDouble__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4420:1: ( ( ruleLInt ) ) |
| // InternalGridSource.g:4421:1: ( ruleLInt ) |
| { |
| // InternalGridSource.g:4421:1: ( ruleLInt ) |
| // InternalGridSource.g:4422:2: ruleLInt |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLDoubleAccess().getLIntParserRuleCall_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleLInt(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLDoubleAccess().getLIntParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LDouble__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__LDouble__Group__1" |
| // InternalGridSource.g:4431:1: rule__LDouble__Group__1 : rule__LDouble__Group__1__Impl ; |
| public final void rule__LDouble__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4435:1: ( rule__LDouble__Group__1__Impl ) |
| // InternalGridSource.g:4436:2: rule__LDouble__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__LDouble__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LDouble__Group__1" |
| |
| |
| // $ANTLR start "rule__LDouble__Group__1__Impl" |
| // InternalGridSource.g:4442:1: rule__LDouble__Group__1__Impl : ( ( rule__LDouble__Group_1__0 )? ) ; |
| public final void rule__LDouble__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4446:1: ( ( ( rule__LDouble__Group_1__0 )? ) ) |
| // InternalGridSource.g:4447:1: ( ( rule__LDouble__Group_1__0 )? ) |
| { |
| // InternalGridSource.g:4447:1: ( ( rule__LDouble__Group_1__0 )? ) |
| // InternalGridSource.g:4448:2: ( rule__LDouble__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLDoubleAccess().getGroup_1()); |
| } |
| // InternalGridSource.g:4449:2: ( rule__LDouble__Group_1__0 )? |
| int alt24=2; |
| int LA24_0 = input.LA(1); |
| |
| if ( (LA24_0==34) ) { |
| alt24=1; |
| } |
| switch (alt24) { |
| case 1 : |
| // InternalGridSource.g:4449:3: rule__LDouble__Group_1__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__LDouble__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLDoubleAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LDouble__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__LDouble__Group_1__0" |
| // InternalGridSource.g:4458:1: rule__LDouble__Group_1__0 : rule__LDouble__Group_1__0__Impl rule__LDouble__Group_1__1 ; |
| public final void rule__LDouble__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4462:1: ( rule__LDouble__Group_1__0__Impl rule__LDouble__Group_1__1 ) |
| // InternalGridSource.g:4463:2: rule__LDouble__Group_1__0__Impl rule__LDouble__Group_1__1 |
| { |
| pushFollow(FOLLOW_50); |
| rule__LDouble__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__LDouble__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LDouble__Group_1__0" |
| |
| |
| // $ANTLR start "rule__LDouble__Group_1__0__Impl" |
| // InternalGridSource.g:4470:1: rule__LDouble__Group_1__0__Impl : ( '.' ) ; |
| public final void rule__LDouble__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4474:1: ( ( '.' ) ) |
| // InternalGridSource.g:4475:1: ( '.' ) |
| { |
| // InternalGridSource.g:4475:1: ( '.' ) |
| // InternalGridSource.g:4476:2: '.' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLDoubleAccess().getFullStopKeyword_1_0()); |
| } |
| match(input,34,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLDoubleAccess().getFullStopKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LDouble__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__LDouble__Group_1__1" |
| // InternalGridSource.g:4485:1: rule__LDouble__Group_1__1 : rule__LDouble__Group_1__1__Impl ; |
| public final void rule__LDouble__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4489:1: ( rule__LDouble__Group_1__1__Impl ) |
| // InternalGridSource.g:4490:2: rule__LDouble__Group_1__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__LDouble__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__LDouble__Group_1__1" |
| |
| |
| // $ANTLR start "rule__LDouble__Group_1__1__Impl" |
| // InternalGridSource.g:4496:1: rule__LDouble__Group_1__1__Impl : ( RULE_INT ) ; |
| public final void rule__LDouble__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4500:1: ( ( RULE_INT ) ) |
| // InternalGridSource.g:4501:1: ( RULE_INT ) |
| { |
| // InternalGridSource.g:4501:1: ( RULE_INT ) |
| // InternalGridSource.g:4502:2: RULE_INT |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getLDoubleAccess().getINTTerminalRuleCall_1_1()); |
| } |
| match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getLDoubleAccess().getINTTerminalRuleCall_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LDouble__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmTypeReference__Group_0__0" |
| // InternalGridSource.g:4512:1: rule__JvmTypeReference__Group_0__0 : rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 ; |
| public final void rule__JvmTypeReference__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4516:1: ( rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 ) |
| // InternalGridSource.g:4517:2: rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 |
| { |
| pushFollow(FOLLOW_51); |
| rule__JvmTypeReference__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmTypeReference__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmTypeReference__Group_0__0" |
| |
| |
| // $ANTLR start "rule__JvmTypeReference__Group_0__0__Impl" |
| // InternalGridSource.g:4524:1: rule__JvmTypeReference__Group_0__0__Impl : ( ruleJvmParameterizedTypeReference ) ; |
| public final void rule__JvmTypeReference__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4528:1: ( ( ruleJvmParameterizedTypeReference ) ) |
| // InternalGridSource.g:4529:1: ( ruleJvmParameterizedTypeReference ) |
| { |
| // InternalGridSource.g:4529:1: ( ruleJvmParameterizedTypeReference ) |
| // InternalGridSource.g:4530:2: ruleJvmParameterizedTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmParameterizedTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmTypeReference__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmTypeReference__Group_0__1" |
| // InternalGridSource.g:4539:1: rule__JvmTypeReference__Group_0__1 : rule__JvmTypeReference__Group_0__1__Impl ; |
| public final void rule__JvmTypeReference__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4543:1: ( rule__JvmTypeReference__Group_0__1__Impl ) |
| // InternalGridSource.g:4544:2: rule__JvmTypeReference__Group_0__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmTypeReference__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__JvmTypeReference__Group_0__1" |
| |
| |
| // $ANTLR start "rule__JvmTypeReference__Group_0__1__Impl" |
| // InternalGridSource.g:4550:1: rule__JvmTypeReference__Group_0__1__Impl : ( ( rule__JvmTypeReference__Group_0_1__0 )* ) ; |
| public final void rule__JvmTypeReference__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4554:1: ( ( ( rule__JvmTypeReference__Group_0_1__0 )* ) ) |
| // InternalGridSource.g:4555:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* ) |
| { |
| // InternalGridSource.g:4555:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* ) |
| // InternalGridSource.g:4556:2: ( rule__JvmTypeReference__Group_0_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); |
| } |
| // InternalGridSource.g:4557:2: ( rule__JvmTypeReference__Group_0_1__0 )* |
| loop25: |
| do { |
| int alt25=2; |
| int LA25_0 = input.LA(1); |
| |
| if ( (LA25_0==59) ) { |
| alt25=1; |
| } |
| |
| |
| switch (alt25) { |
| case 1 : |
| // InternalGridSource.g:4557:3: rule__JvmTypeReference__Group_0_1__0 |
| { |
| pushFollow(FOLLOW_52); |
| rule__JvmTypeReference__Group_0_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop25; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmTypeReference__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmTypeReference__Group_0_1__0" |
| // InternalGridSource.g:4566:1: rule__JvmTypeReference__Group_0_1__0 : rule__JvmTypeReference__Group_0_1__0__Impl ; |
| public final void rule__JvmTypeReference__Group_0_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4570:1: ( rule__JvmTypeReference__Group_0_1__0__Impl ) |
| // InternalGridSource.g:4571:2: rule__JvmTypeReference__Group_0_1__0__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmTypeReference__Group_0_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmTypeReference__Group_0_1__0" |
| |
| |
| // $ANTLR start "rule__JvmTypeReference__Group_0_1__0__Impl" |
| // InternalGridSource.g:4577:1: rule__JvmTypeReference__Group_0_1__0__Impl : ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) ; |
| public final void rule__JvmTypeReference__Group_0_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4581:1: ( ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) ) |
| // InternalGridSource.g:4582:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) |
| { |
| // InternalGridSource.g:4582:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) |
| // InternalGridSource.g:4583:2: ( rule__JvmTypeReference__Group_0_1_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); |
| } |
| // InternalGridSource.g:4584:2: ( rule__JvmTypeReference__Group_0_1_0__0 ) |
| // InternalGridSource.g:4584:3: rule__JvmTypeReference__Group_0_1_0__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmTypeReference__Group_0_1_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmTypeReference__Group_0_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0" |
| // InternalGridSource.g:4593:1: rule__JvmTypeReference__Group_0_1_0__0 : rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 ; |
| public final void rule__JvmTypeReference__Group_0_1_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4597:1: ( rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 ) |
| // InternalGridSource.g:4598:2: rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 |
| { |
| pushFollow(FOLLOW_51); |
| rule__JvmTypeReference__Group_0_1_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmTypeReference__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__JvmTypeReference__Group_0_1_0__0" |
| |
| |
| // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0__Impl" |
| // InternalGridSource.g:4605:1: rule__JvmTypeReference__Group_0_1_0__0__Impl : ( () ) ; |
| public final void rule__JvmTypeReference__Group_0_1_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4609:1: ( ( () ) ) |
| // InternalGridSource.g:4610:1: ( () ) |
| { |
| // InternalGridSource.g:4610:1: ( () ) |
| // InternalGridSource.g:4611:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); |
| } |
| // InternalGridSource.g:4612:2: () |
| // InternalGridSource.g:4612:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1" |
| // InternalGridSource.g:4620:1: rule__JvmTypeReference__Group_0_1_0__1 : rule__JvmTypeReference__Group_0_1_0__1__Impl ; |
| public final void rule__JvmTypeReference__Group_0_1_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4624:1: ( rule__JvmTypeReference__Group_0_1_0__1__Impl ) |
| // InternalGridSource.g:4625:2: rule__JvmTypeReference__Group_0_1_0__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmTypeReference__Group_0_1_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1" |
| |
| |
| // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1__Impl" |
| // InternalGridSource.g:4631:1: rule__JvmTypeReference__Group_0_1_0__1__Impl : ( ruleArrayBrackets ) ; |
| public final void rule__JvmTypeReference__Group_0_1_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4635:1: ( ( ruleArrayBrackets ) ) |
| // InternalGridSource.g:4636:1: ( ruleArrayBrackets ) |
| { |
| // InternalGridSource.g:4636:1: ( ruleArrayBrackets ) |
| // InternalGridSource.g:4637:2: ruleArrayBrackets |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleArrayBrackets(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__ArrayBrackets__Group__0" |
| // InternalGridSource.g:4647:1: rule__ArrayBrackets__Group__0 : rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 ; |
| public final void rule__ArrayBrackets__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4651:1: ( rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 ) |
| // InternalGridSource.g:4652:2: rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 |
| { |
| pushFollow(FOLLOW_53); |
| rule__ArrayBrackets__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__ArrayBrackets__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ArrayBrackets__Group__0" |
| |
| |
| // $ANTLR start "rule__ArrayBrackets__Group__0__Impl" |
| // InternalGridSource.g:4659:1: rule__ArrayBrackets__Group__0__Impl : ( '[' ) ; |
| public final void rule__ArrayBrackets__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4663:1: ( ( '[' ) ) |
| // InternalGridSource.g:4664:1: ( '[' ) |
| { |
| // InternalGridSource.g:4664:1: ( '[' ) |
| // InternalGridSource.g:4665:2: '[' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); |
| } |
| match(input,59,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ArrayBrackets__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ArrayBrackets__Group__1" |
| // InternalGridSource.g:4674:1: rule__ArrayBrackets__Group__1 : rule__ArrayBrackets__Group__1__Impl ; |
| public final void rule__ArrayBrackets__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4678:1: ( rule__ArrayBrackets__Group__1__Impl ) |
| // InternalGridSource.g:4679:2: rule__ArrayBrackets__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__ArrayBrackets__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ArrayBrackets__Group__1" |
| |
| |
| // $ANTLR start "rule__ArrayBrackets__Group__1__Impl" |
| // InternalGridSource.g:4685:1: rule__ArrayBrackets__Group__1__Impl : ( ']' ) ; |
| public final void rule__ArrayBrackets__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4689:1: ( ( ']' ) ) |
| // InternalGridSource.g:4690:1: ( ']' ) |
| { |
| // InternalGridSource.g:4690:1: ( ']' ) |
| // InternalGridSource.g:4691:2: ']' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); |
| } |
| match(input,60,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ArrayBrackets__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group__0" |
| // InternalGridSource.g:4701:1: rule__XFunctionTypeRef__Group__0 : rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 ; |
| public final void rule__XFunctionTypeRef__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4705:1: ( rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 ) |
| // InternalGridSource.g:4706:2: rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 |
| { |
| pushFollow(FOLLOW_6); |
| rule__XFunctionTypeRef__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group__0" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group__0__Impl" |
| // InternalGridSource.g:4713:1: rule__XFunctionTypeRef__Group__0__Impl : ( ( rule__XFunctionTypeRef__Group_0__0 )? ) ; |
| public final void rule__XFunctionTypeRef__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4717:1: ( ( ( rule__XFunctionTypeRef__Group_0__0 )? ) ) |
| // InternalGridSource.g:4718:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? ) |
| { |
| // InternalGridSource.g:4718:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? ) |
| // InternalGridSource.g:4719:2: ( rule__XFunctionTypeRef__Group_0__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); |
| } |
| // InternalGridSource.g:4720:2: ( rule__XFunctionTypeRef__Group_0__0 )? |
| int alt26=2; |
| int LA26_0 = input.LA(1); |
| |
| if ( (LA26_0==50) ) { |
| alt26=1; |
| } |
| switch (alt26) { |
| case 1 : |
| // InternalGridSource.g:4720:3: rule__XFunctionTypeRef__Group_0__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__Group_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group__1" |
| // InternalGridSource.g:4728:1: rule__XFunctionTypeRef__Group__1 : rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 ; |
| public final void rule__XFunctionTypeRef__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4732:1: ( rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 ) |
| // InternalGridSource.g:4733:2: rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 |
| { |
| pushFollow(FOLLOW_6); |
| rule__XFunctionTypeRef__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group__1" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group__1__Impl" |
| // InternalGridSource.g:4740:1: rule__XFunctionTypeRef__Group__1__Impl : ( '=>' ) ; |
| public final void rule__XFunctionTypeRef__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4744:1: ( ( '=>' ) ) |
| // InternalGridSource.g:4745:1: ( '=>' ) |
| { |
| // InternalGridSource.g:4745:1: ( '=>' ) |
| // InternalGridSource.g:4746:2: '=>' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); |
| } |
| match(input,61,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group__2" |
| // InternalGridSource.g:4755:1: rule__XFunctionTypeRef__Group__2 : rule__XFunctionTypeRef__Group__2__Impl ; |
| public final void rule__XFunctionTypeRef__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4759:1: ( rule__XFunctionTypeRef__Group__2__Impl ) |
| // InternalGridSource.g:4760:2: rule__XFunctionTypeRef__Group__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group__2" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group__2__Impl" |
| // InternalGridSource.g:4766:1: rule__XFunctionTypeRef__Group__2__Impl : ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) ; |
| public final void rule__XFunctionTypeRef__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4770:1: ( ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) ) |
| // InternalGridSource.g:4771:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) |
| { |
| // InternalGridSource.g:4771:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) |
| // InternalGridSource.g:4772:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); |
| } |
| // InternalGridSource.g:4773:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) |
| // InternalGridSource.g:4773:3: rule__XFunctionTypeRef__ReturnTypeAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__ReturnTypeAssignment_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0__0" |
| // InternalGridSource.g:4782:1: rule__XFunctionTypeRef__Group_0__0 : rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 ; |
| public final void rule__XFunctionTypeRef__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4786:1: ( rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 ) |
| // InternalGridSource.g:4787:2: rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 |
| { |
| pushFollow(FOLLOW_54); |
| rule__XFunctionTypeRef__Group_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__Group_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group_0__0" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0__0__Impl" |
| // InternalGridSource.g:4794:1: rule__XFunctionTypeRef__Group_0__0__Impl : ( '(' ) ; |
| public final void rule__XFunctionTypeRef__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4798:1: ( ( '(' ) ) |
| // InternalGridSource.g:4799:1: ( '(' ) |
| { |
| // InternalGridSource.g:4799:1: ( '(' ) |
| // InternalGridSource.g:4800:2: '(' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); |
| } |
| match(input,50,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0__1" |
| // InternalGridSource.g:4809:1: rule__XFunctionTypeRef__Group_0__1 : rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 ; |
| public final void rule__XFunctionTypeRef__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4813:1: ( rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 ) |
| // InternalGridSource.g:4814:2: rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 |
| { |
| pushFollow(FOLLOW_54); |
| rule__XFunctionTypeRef__Group_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__Group_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group_0__1" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0__1__Impl" |
| // InternalGridSource.g:4821:1: rule__XFunctionTypeRef__Group_0__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) ; |
| public final void rule__XFunctionTypeRef__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4825:1: ( ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) ) |
| // InternalGridSource.g:4826:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) |
| { |
| // InternalGridSource.g:4826:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) |
| // InternalGridSource.g:4827:2: ( rule__XFunctionTypeRef__Group_0_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); |
| } |
| // InternalGridSource.g:4828:2: ( rule__XFunctionTypeRef__Group_0_1__0 )? |
| int alt27=2; |
| int LA27_0 = input.LA(1); |
| |
| if ( (LA27_0==RULE_ID||LA27_0==50||LA27_0==61) ) { |
| alt27=1; |
| } |
| switch (alt27) { |
| case 1 : |
| // InternalGridSource.g:4828:3: rule__XFunctionTypeRef__Group_0_1__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__Group_0_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0__2" |
| // InternalGridSource.g:4836:1: rule__XFunctionTypeRef__Group_0__2 : rule__XFunctionTypeRef__Group_0__2__Impl ; |
| public final void rule__XFunctionTypeRef__Group_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4840:1: ( rule__XFunctionTypeRef__Group_0__2__Impl ) |
| // InternalGridSource.g:4841:2: rule__XFunctionTypeRef__Group_0__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__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__XFunctionTypeRef__Group_0__2" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0__2__Impl" |
| // InternalGridSource.g:4847:1: rule__XFunctionTypeRef__Group_0__2__Impl : ( ')' ) ; |
| public final void rule__XFunctionTypeRef__Group_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4851:1: ( ( ')' ) ) |
| // InternalGridSource.g:4852:1: ( ')' ) |
| { |
| // InternalGridSource.g:4852:1: ( ')' ) |
| // InternalGridSource.g:4853:2: ')' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); |
| } |
| match(input,51,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0" |
| // InternalGridSource.g:4863:1: rule__XFunctionTypeRef__Group_0_1__0 : rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 ; |
| public final void rule__XFunctionTypeRef__Group_0_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4867:1: ( rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 ) |
| // InternalGridSource.g:4868:2: rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 |
| { |
| pushFollow(FOLLOW_55); |
| rule__XFunctionTypeRef__Group_0_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__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__XFunctionTypeRef__Group_0_1__0" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0__Impl" |
| // InternalGridSource.g:4875:1: rule__XFunctionTypeRef__Group_0_1__0__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) ; |
| public final void rule__XFunctionTypeRef__Group_0_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4879:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) ) |
| // InternalGridSource.g:4880:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) |
| { |
| // InternalGridSource.g:4880:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) |
| // InternalGridSource.g:4881:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); |
| } |
| // InternalGridSource.g:4882:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) |
| // InternalGridSource.g:4882:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1" |
| // InternalGridSource.g:4890:1: rule__XFunctionTypeRef__Group_0_1__1 : rule__XFunctionTypeRef__Group_0_1__1__Impl ; |
| public final void rule__XFunctionTypeRef__Group_0_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4894:1: ( rule__XFunctionTypeRef__Group_0_1__1__Impl ) |
| // InternalGridSource.g:4895:2: rule__XFunctionTypeRef__Group_0_1__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__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__XFunctionTypeRef__Group_0_1__1" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1__Impl" |
| // InternalGridSource.g:4901:1: rule__XFunctionTypeRef__Group_0_1__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) ; |
| public final void rule__XFunctionTypeRef__Group_0_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4905:1: ( ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) ) |
| // InternalGridSource.g:4906:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) |
| { |
| // InternalGridSource.g:4906:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) |
| // InternalGridSource.g:4907:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); |
| } |
| // InternalGridSource.g:4908:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )* |
| loop28: |
| do { |
| int alt28=2; |
| int LA28_0 = input.LA(1); |
| |
| if ( (LA28_0==62) ) { |
| alt28=1; |
| } |
| |
| |
| switch (alt28) { |
| case 1 : |
| // InternalGridSource.g:4908:3: rule__XFunctionTypeRef__Group_0_1_1__0 |
| { |
| pushFollow(FOLLOW_56); |
| rule__XFunctionTypeRef__Group_0_1_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop28; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0" |
| // InternalGridSource.g:4917:1: rule__XFunctionTypeRef__Group_0_1_1__0 : rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 ; |
| public final void rule__XFunctionTypeRef__Group_0_1_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4921:1: ( rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 ) |
| // InternalGridSource.g:4922:2: rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 |
| { |
| pushFollow(FOLLOW_6); |
| rule__XFunctionTypeRef__Group_0_1_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__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__XFunctionTypeRef__Group_0_1_1__0" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0__Impl" |
| // InternalGridSource.g:4929:1: rule__XFunctionTypeRef__Group_0_1_1__0__Impl : ( ',' ) ; |
| public final void rule__XFunctionTypeRef__Group_0_1_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4933:1: ( ( ',' ) ) |
| // InternalGridSource.g:4934:1: ( ',' ) |
| { |
| // InternalGridSource.g:4934:1: ( ',' ) |
| // InternalGridSource.g:4935:2: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); |
| } |
| match(input,62,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1" |
| // InternalGridSource.g:4944:1: rule__XFunctionTypeRef__Group_0_1_1__1 : rule__XFunctionTypeRef__Group_0_1_1__1__Impl ; |
| public final void rule__XFunctionTypeRef__Group_0_1_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4948:1: ( rule__XFunctionTypeRef__Group_0_1_1__1__Impl ) |
| // InternalGridSource.g:4949:2: rule__XFunctionTypeRef__Group_0_1_1__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__Group_0_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__XFunctionTypeRef__Group_0_1_1__1" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1__Impl" |
| // InternalGridSource.g:4955:1: rule__XFunctionTypeRef__Group_0_1_1__1__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) ; |
| public final void rule__XFunctionTypeRef__Group_0_1_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4959:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) ) |
| // InternalGridSource.g:4960:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) |
| { |
| // InternalGridSource.g:4960:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) |
| // InternalGridSource.g:4961:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); |
| } |
| // InternalGridSource.g:4962:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) |
| // InternalGridSource.g:4962:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0" |
| // InternalGridSource.g:4971:1: rule__JvmParameterizedTypeReference__Group__0 : rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 ; |
| public final void rule__JvmParameterizedTypeReference__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4975:1: ( rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 ) |
| // InternalGridSource.g:4976:2: rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 |
| { |
| pushFollow(FOLLOW_57); |
| rule__JvmParameterizedTypeReference__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0__Impl" |
| // InternalGridSource.g:4983:1: rule__JvmParameterizedTypeReference__Group__0__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) ; |
| public final void rule__JvmParameterizedTypeReference__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:4987:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) ) |
| // InternalGridSource.g:4988:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) |
| { |
| // InternalGridSource.g:4988:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) |
| // InternalGridSource.g:4989:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); |
| } |
| // InternalGridSource.g:4990:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) |
| // InternalGridSource.g:4990:3: rule__JvmParameterizedTypeReference__TypeAssignment_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__TypeAssignment_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1" |
| // InternalGridSource.g:4998:1: rule__JvmParameterizedTypeReference__Group__1 : rule__JvmParameterizedTypeReference__Group__1__Impl ; |
| public final void rule__JvmParameterizedTypeReference__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5002:1: ( rule__JvmParameterizedTypeReference__Group__1__Impl ) |
| // InternalGridSource.g:5003:2: rule__JvmParameterizedTypeReference__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1__Impl" |
| // InternalGridSource.g:5009:1: rule__JvmParameterizedTypeReference__Group__1__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) ; |
| public final void rule__JvmParameterizedTypeReference__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5013:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) ) |
| // InternalGridSource.g:5014:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) |
| { |
| // InternalGridSource.g:5014:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) |
| // InternalGridSource.g:5015:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); |
| } |
| // InternalGridSource.g:5016:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )? |
| int alt29=2; |
| int LA29_0 = input.LA(1); |
| |
| if ( (LA29_0==63) ) { |
| alt29=1; |
| } |
| switch (alt29) { |
| case 1 : |
| // InternalGridSource.g:5016:3: rule__JvmParameterizedTypeReference__Group_1__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0" |
| // InternalGridSource.g:5025:1: rule__JvmParameterizedTypeReference__Group_1__0 : rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5029:1: ( rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 ) |
| // InternalGridSource.g:5030:2: rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 |
| { |
| pushFollow(FOLLOW_58); |
| rule__JvmParameterizedTypeReference__Group_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0__Impl" |
| // InternalGridSource.g:5037:1: rule__JvmParameterizedTypeReference__Group_1__0__Impl : ( ( '<' ) ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5041:1: ( ( ( '<' ) ) ) |
| // InternalGridSource.g:5042:1: ( ( '<' ) ) |
| { |
| // InternalGridSource.g:5042:1: ( ( '<' ) ) |
| // InternalGridSource.g:5043:2: ( '<' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); |
| } |
| // InternalGridSource.g:5044:2: ( '<' ) |
| // InternalGridSource.g:5044:3: '<' |
| { |
| match(input,63,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1" |
| // InternalGridSource.g:5052:1: rule__JvmParameterizedTypeReference__Group_1__1 : rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5056:1: ( rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 ) |
| // InternalGridSource.g:5057:2: rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 |
| { |
| pushFollow(FOLLOW_59); |
| rule__JvmParameterizedTypeReference__Group_1__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1__Impl" |
| // InternalGridSource.g:5064:1: rule__JvmParameterizedTypeReference__Group_1__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5068:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) ) |
| // InternalGridSource.g:5069:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) |
| { |
| // InternalGridSource.g:5069:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) |
| // InternalGridSource.g:5070:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); |
| } |
| // InternalGridSource.g:5071:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) |
| // InternalGridSource.g:5071:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2" |
| // InternalGridSource.g:5079:1: rule__JvmParameterizedTypeReference__Group_1__2 : rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5083:1: ( rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 ) |
| // InternalGridSource.g:5084:2: rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 |
| { |
| pushFollow(FOLLOW_59); |
| rule__JvmParameterizedTypeReference__Group_1__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2__Impl" |
| // InternalGridSource.g:5091:1: rule__JvmParameterizedTypeReference__Group_1__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5095:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) ) |
| // InternalGridSource.g:5096:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) |
| { |
| // InternalGridSource.g:5096:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) |
| // InternalGridSource.g:5097:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); |
| } |
| // InternalGridSource.g:5098:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* |
| loop30: |
| do { |
| int alt30=2; |
| int LA30_0 = input.LA(1); |
| |
| if ( (LA30_0==62) ) { |
| alt30=1; |
| } |
| |
| |
| switch (alt30) { |
| case 1 : |
| // InternalGridSource.g:5098:3: rule__JvmParameterizedTypeReference__Group_1_2__0 |
| { |
| pushFollow(FOLLOW_56); |
| rule__JvmParameterizedTypeReference__Group_1_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop30; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3" |
| // InternalGridSource.g:5106:1: rule__JvmParameterizedTypeReference__Group_1__3 : rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5110:1: ( rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 ) |
| // InternalGridSource.g:5111:2: rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 |
| { |
| pushFollow(FOLLOW_21); |
| rule__JvmParameterizedTypeReference__Group_1__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1__4(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3__Impl" |
| // InternalGridSource.g:5118:1: rule__JvmParameterizedTypeReference__Group_1__3__Impl : ( '>' ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5122:1: ( ( '>' ) ) |
| // InternalGridSource.g:5123:1: ( '>' ) |
| { |
| // InternalGridSource.g:5123:1: ( '>' ) |
| // InternalGridSource.g:5124:2: '>' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); |
| } |
| match(input,64,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4" |
| // InternalGridSource.g:5133:1: rule__JvmParameterizedTypeReference__Group_1__4 : rule__JvmParameterizedTypeReference__Group_1__4__Impl ; |
| public final void rule__JvmParameterizedTypeReference__Group_1__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5137:1: ( rule__JvmParameterizedTypeReference__Group_1__4__Impl ) |
| // InternalGridSource.g:5138:2: rule__JvmParameterizedTypeReference__Group_1__4__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__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__JvmParameterizedTypeReference__Group_1__4" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4__Impl" |
| // InternalGridSource.g:5144:1: rule__JvmParameterizedTypeReference__Group_1__4__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5148:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) ) |
| // InternalGridSource.g:5149:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) |
| { |
| // InternalGridSource.g:5149:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) |
| // InternalGridSource.g:5150:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); |
| } |
| // InternalGridSource.g:5151:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* |
| loop31: |
| do { |
| int alt31=2; |
| int LA31_0 = input.LA(1); |
| |
| if ( (LA31_0==34) ) { |
| alt31=1; |
| } |
| |
| |
| switch (alt31) { |
| case 1 : |
| // InternalGridSource.g:5151:3: rule__JvmParameterizedTypeReference__Group_1_4__0 |
| { |
| pushFollow(FOLLOW_46); |
| rule__JvmParameterizedTypeReference__Group_1_4__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop31; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__4__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0" |
| // InternalGridSource.g:5160:1: rule__JvmParameterizedTypeReference__Group_1_2__0 : rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5164:1: ( rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 ) |
| // InternalGridSource.g:5165:2: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 |
| { |
| pushFollow(FOLLOW_58); |
| rule__JvmParameterizedTypeReference__Group_1_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__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__JvmParameterizedTypeReference__Group_1_2__0" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl" |
| // InternalGridSource.g:5172:1: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl : ( ',' ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5176:1: ( ( ',' ) ) |
| // InternalGridSource.g:5177:1: ( ',' ) |
| { |
| // InternalGridSource.g:5177:1: ( ',' ) |
| // InternalGridSource.g:5178:2: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); |
| } |
| match(input,62,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1" |
| // InternalGridSource.g:5187:1: rule__JvmParameterizedTypeReference__Group_1_2__1 : rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5191:1: ( rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ) |
| // InternalGridSource.g:5192:2: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__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__JvmParameterizedTypeReference__Group_1_2__1" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl" |
| // InternalGridSource.g:5198:1: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5202:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) ) |
| // InternalGridSource.g:5203:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) |
| { |
| // InternalGridSource.g:5203:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) |
| // InternalGridSource.g:5204:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); |
| } |
| // InternalGridSource.g:5205:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) |
| // InternalGridSource.g:5205:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0" |
| // InternalGridSource.g:5214:1: rule__JvmParameterizedTypeReference__Group_1_4__0 : rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5218:1: ( rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 ) |
| // InternalGridSource.g:5219:2: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 |
| { |
| pushFollow(FOLLOW_4); |
| rule__JvmParameterizedTypeReference__Group_1_4__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl" |
| // InternalGridSource.g:5226:1: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5230:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) ) |
| // InternalGridSource.g:5231:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) |
| { |
| // InternalGridSource.g:5231:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) |
| // InternalGridSource.g:5232:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); |
| } |
| // InternalGridSource.g:5233:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) |
| // InternalGridSource.g:5233:3: rule__JvmParameterizedTypeReference__Group_1_4_0__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1" |
| // InternalGridSource.g:5241:1: rule__JvmParameterizedTypeReference__Group_1_4__1 : rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5245:1: ( rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 ) |
| // InternalGridSource.g:5246:2: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 |
| { |
| pushFollow(FOLLOW_57); |
| rule__JvmParameterizedTypeReference__Group_1_4__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl" |
| // InternalGridSource.g:5253:1: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5257:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) ) |
| // InternalGridSource.g:5258:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) |
| { |
| // InternalGridSource.g:5258:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) |
| // InternalGridSource.g:5259:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); |
| } |
| // InternalGridSource.g:5260:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) |
| // InternalGridSource.g:5260:3: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2" |
| // InternalGridSource.g:5268:1: rule__JvmParameterizedTypeReference__Group_1_4__2 : rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5272:1: ( rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ) |
| // InternalGridSource.g:5273:2: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl" |
| // InternalGridSource.g:5279:1: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5283:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) ) |
| // InternalGridSource.g:5284:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) |
| { |
| // InternalGridSource.g:5284:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) |
| // InternalGridSource.g:5285:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); |
| } |
| // InternalGridSource.g:5286:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? |
| int alt32=2; |
| int LA32_0 = input.LA(1); |
| |
| if ( (LA32_0==63) ) { |
| alt32=1; |
| } |
| switch (alt32) { |
| case 1 : |
| // InternalGridSource.g:5286:3: rule__JvmParameterizedTypeReference__Group_1_4_2__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0" |
| // InternalGridSource.g:5295:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5299:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ) |
| // InternalGridSource.g:5300:2: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl" |
| // InternalGridSource.g:5306:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5310:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) ) |
| // InternalGridSource.g:5311:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) |
| { |
| // InternalGridSource.g:5311:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) |
| // InternalGridSource.g:5312:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); |
| } |
| // InternalGridSource.g:5313:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) |
| // InternalGridSource.g:5313:3: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_0_0__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0" |
| // InternalGridSource.g:5322:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5326:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ) |
| // InternalGridSource.g:5327:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 |
| { |
| pushFollow(FOLLOW_21); |
| rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_0_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl" |
| // InternalGridSource.g:5334:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl : ( () ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5338:1: ( ( () ) ) |
| // InternalGridSource.g:5339:1: ( () ) |
| { |
| // InternalGridSource.g:5339:1: ( () ) |
| // InternalGridSource.g:5340:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); |
| } |
| // InternalGridSource.g:5341:2: () |
| // InternalGridSource.g:5341:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1" |
| // InternalGridSource.g:5349:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5353:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ) |
| // InternalGridSource.g:5354:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl" |
| // InternalGridSource.g:5360:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl : ( '.' ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5364:1: ( ( '.' ) ) |
| // InternalGridSource.g:5365:1: ( '.' ) |
| { |
| // InternalGridSource.g:5365:1: ( '.' ) |
| // InternalGridSource.g:5366:2: '.' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); |
| } |
| match(input,34,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0" |
| // InternalGridSource.g:5376:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5380:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 ) |
| // InternalGridSource.g:5381:2: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 |
| { |
| pushFollow(FOLLOW_58); |
| rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl" |
| // InternalGridSource.g:5388:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl : ( ( '<' ) ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5392:1: ( ( ( '<' ) ) ) |
| // InternalGridSource.g:5393:1: ( ( '<' ) ) |
| { |
| // InternalGridSource.g:5393:1: ( ( '<' ) ) |
| // InternalGridSource.g:5394:2: ( '<' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); |
| } |
| // InternalGridSource.g:5395:2: ( '<' ) |
| // InternalGridSource.g:5395:3: '<' |
| { |
| match(input,63,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1" |
| // InternalGridSource.g:5403:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5407:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 ) |
| // InternalGridSource.g:5408:2: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 |
| { |
| pushFollow(FOLLOW_59); |
| rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_2__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl" |
| // InternalGridSource.g:5415:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5419:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) ) |
| // InternalGridSource.g:5420:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) |
| { |
| // InternalGridSource.g:5420:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) |
| // InternalGridSource.g:5421:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); |
| } |
| // InternalGridSource.g:5422:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) |
| // InternalGridSource.g:5422:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2" |
| // InternalGridSource.g:5430:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2 : rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5434:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 ) |
| // InternalGridSource.g:5435:2: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 |
| { |
| pushFollow(FOLLOW_59); |
| rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_2__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl" |
| // InternalGridSource.g:5442:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5446:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) ) |
| // InternalGridSource.g:5447:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) |
| { |
| // InternalGridSource.g:5447:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) |
| // InternalGridSource.g:5448:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); |
| } |
| // InternalGridSource.g:5449:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* |
| loop33: |
| do { |
| int alt33=2; |
| int LA33_0 = input.LA(1); |
| |
| if ( (LA33_0==62) ) { |
| alt33=1; |
| } |
| |
| |
| switch (alt33) { |
| case 1 : |
| // InternalGridSource.g:5449:3: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 |
| { |
| pushFollow(FOLLOW_56); |
| rule__JvmParameterizedTypeReference__Group_1_4_2_2__0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop33; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3" |
| // InternalGridSource.g:5457:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3 : rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5461:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ) |
| // InternalGridSource.g:5462:2: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl" |
| // InternalGridSource.g:5468:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl : ( '>' ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5472:1: ( ( '>' ) ) |
| // InternalGridSource.g:5473:1: ( '>' ) |
| { |
| // InternalGridSource.g:5473:1: ( '>' ) |
| // InternalGridSource.g:5474:2: '>' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); |
| } |
| match(input,64,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0" |
| // InternalGridSource.g:5484:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5488:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ) |
| // InternalGridSource.g:5489:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 |
| { |
| pushFollow(FOLLOW_58); |
| rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_2_2__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl" |
| // InternalGridSource.g:5496:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl : ( ',' ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5500:1: ( ( ',' ) ) |
| // InternalGridSource.g:5501:1: ( ',' ) |
| { |
| // InternalGridSource.g:5501:1: ( ',' ) |
| // InternalGridSource.g:5502:2: ',' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); |
| } |
| match(input,62,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1" |
| // InternalGridSource.g:5511:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5515:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ) |
| // InternalGridSource.g:5516:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__Group_1_4_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__JvmParameterizedTypeReference__Group_1_4_2_2__1" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl" |
| // InternalGridSource.g:5522:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) ; |
| public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5526:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) ) |
| // InternalGridSource.g:5527:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) |
| { |
| // InternalGridSource.g:5527:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) |
| // InternalGridSource.g:5528:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); |
| } |
| // InternalGridSource.g:5529:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) |
| // InternalGridSource.g:5529:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group__0" |
| // InternalGridSource.g:5538:1: rule__JvmWildcardTypeReference__Group__0 : rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 ; |
| public final void rule__JvmWildcardTypeReference__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5542:1: ( rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 ) |
| // InternalGridSource.g:5543:2: rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 |
| { |
| pushFollow(FOLLOW_58); |
| rule__JvmWildcardTypeReference__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__Group__0" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group__0__Impl" |
| // InternalGridSource.g:5550:1: rule__JvmWildcardTypeReference__Group__0__Impl : ( () ) ; |
| public final void rule__JvmWildcardTypeReference__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5554:1: ( ( () ) ) |
| // InternalGridSource.g:5555:1: ( () ) |
| { |
| // InternalGridSource.g:5555:1: ( () ) |
| // InternalGridSource.g:5556:2: () |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); |
| } |
| // InternalGridSource.g:5557:2: () |
| // InternalGridSource.g:5557:3: |
| { |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group__1" |
| // InternalGridSource.g:5565:1: rule__JvmWildcardTypeReference__Group__1 : rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 ; |
| public final void rule__JvmWildcardTypeReference__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5569:1: ( rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 ) |
| // InternalGridSource.g:5570:2: rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 |
| { |
| pushFollow(FOLLOW_60); |
| rule__JvmWildcardTypeReference__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__Group__1" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group__1__Impl" |
| // InternalGridSource.g:5577:1: rule__JvmWildcardTypeReference__Group__1__Impl : ( '?' ) ; |
| public final void rule__JvmWildcardTypeReference__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5581:1: ( ( '?' ) ) |
| // InternalGridSource.g:5582:1: ( '?' ) |
| { |
| // InternalGridSource.g:5582:1: ( '?' ) |
| // InternalGridSource.g:5583:2: '?' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); |
| } |
| match(input,65,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group__2" |
| // InternalGridSource.g:5592:1: rule__JvmWildcardTypeReference__Group__2 : rule__JvmWildcardTypeReference__Group__2__Impl ; |
| public final void rule__JvmWildcardTypeReference__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5596:1: ( rule__JvmWildcardTypeReference__Group__2__Impl ) |
| // InternalGridSource.g:5597:2: rule__JvmWildcardTypeReference__Group__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__Group__2" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group__2__Impl" |
| // InternalGridSource.g:5603:1: rule__JvmWildcardTypeReference__Group__2__Impl : ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) ; |
| public final void rule__JvmWildcardTypeReference__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5607:1: ( ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) ) |
| // InternalGridSource.g:5608:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) |
| { |
| // InternalGridSource.g:5608:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) |
| // InternalGridSource.g:5609:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); |
| } |
| // InternalGridSource.g:5610:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )? |
| int alt34=2; |
| int LA34_0 = input.LA(1); |
| |
| if ( (LA34_0==66||LA34_0==68) ) { |
| alt34=1; |
| } |
| switch (alt34) { |
| case 1 : |
| // InternalGridSource.g:5610:3: rule__JvmWildcardTypeReference__Alternatives_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__Alternatives_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0" |
| // InternalGridSource.g:5619:1: rule__JvmWildcardTypeReference__Group_2_0__0 : rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 ; |
| public final void rule__JvmWildcardTypeReference__Group_2_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5623:1: ( rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 ) |
| // InternalGridSource.g:5624:2: rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 |
| { |
| pushFollow(FOLLOW_61); |
| rule__JvmWildcardTypeReference__Group_2_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__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__JvmWildcardTypeReference__Group_2_0__0" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0__Impl" |
| // InternalGridSource.g:5631:1: rule__JvmWildcardTypeReference__Group_2_0__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) ; |
| public final void rule__JvmWildcardTypeReference__Group_2_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5635:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) ) |
| // InternalGridSource.g:5636:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) |
| { |
| // InternalGridSource.g:5636:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) |
| // InternalGridSource.g:5637:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); |
| } |
| // InternalGridSource.g:5638:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) |
| // InternalGridSource.g:5638:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1" |
| // InternalGridSource.g:5646:1: rule__JvmWildcardTypeReference__Group_2_0__1 : rule__JvmWildcardTypeReference__Group_2_0__1__Impl ; |
| public final void rule__JvmWildcardTypeReference__Group_2_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5650:1: ( rule__JvmWildcardTypeReference__Group_2_0__1__Impl ) |
| // InternalGridSource.g:5651:2: rule__JvmWildcardTypeReference__Group_2_0__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__Group_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__JvmWildcardTypeReference__Group_2_0__1" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1__Impl" |
| // InternalGridSource.g:5657:1: rule__JvmWildcardTypeReference__Group_2_0__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) ; |
| public final void rule__JvmWildcardTypeReference__Group_2_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5661:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) ) |
| // InternalGridSource.g:5662:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) |
| { |
| // InternalGridSource.g:5662:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) |
| // InternalGridSource.g:5663:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); |
| } |
| // InternalGridSource.g:5664:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* |
| loop35: |
| do { |
| int alt35=2; |
| int LA35_0 = input.LA(1); |
| |
| if ( (LA35_0==67) ) { |
| alt35=1; |
| } |
| |
| |
| switch (alt35) { |
| case 1 : |
| // InternalGridSource.g:5664:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 |
| { |
| pushFollow(FOLLOW_62); |
| rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop35; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0" |
| // InternalGridSource.g:5673:1: rule__JvmWildcardTypeReference__Group_2_1__0 : rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 ; |
| public final void rule__JvmWildcardTypeReference__Group_2_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5677:1: ( rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 ) |
| // InternalGridSource.g:5678:2: rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 |
| { |
| pushFollow(FOLLOW_61); |
| rule__JvmWildcardTypeReference__Group_2_1__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__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__JvmWildcardTypeReference__Group_2_1__0" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0__Impl" |
| // InternalGridSource.g:5685:1: rule__JvmWildcardTypeReference__Group_2_1__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) ; |
| public final void rule__JvmWildcardTypeReference__Group_2_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5689:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) ) |
| // InternalGridSource.g:5690:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) |
| { |
| // InternalGridSource.g:5690:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) |
| // InternalGridSource.g:5691:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); |
| } |
| // InternalGridSource.g:5692:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) |
| // InternalGridSource.g:5692:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1" |
| // InternalGridSource.g:5700:1: rule__JvmWildcardTypeReference__Group_2_1__1 : rule__JvmWildcardTypeReference__Group_2_1__1__Impl ; |
| public final void rule__JvmWildcardTypeReference__Group_2_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5704:1: ( rule__JvmWildcardTypeReference__Group_2_1__1__Impl ) |
| // InternalGridSource.g:5705:2: rule__JvmWildcardTypeReference__Group_2_1__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmWildcardTypeReference__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__JvmWildcardTypeReference__Group_2_1__1" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1__Impl" |
| // InternalGridSource.g:5711:1: rule__JvmWildcardTypeReference__Group_2_1__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) ; |
| public final void rule__JvmWildcardTypeReference__Group_2_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5715:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) ) |
| // InternalGridSource.g:5716:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) |
| { |
| // InternalGridSource.g:5716:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) |
| // InternalGridSource.g:5717:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); |
| } |
| // InternalGridSource.g:5718:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* |
| loop36: |
| do { |
| int alt36=2; |
| int LA36_0 = input.LA(1); |
| |
| if ( (LA36_0==67) ) { |
| alt36=1; |
| } |
| |
| |
| switch (alt36) { |
| case 1 : |
| // InternalGridSource.g:5718:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 |
| { |
| pushFollow(FOLLOW_62); |
| rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop36; |
| } |
| } while (true); |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmUpperBound__Group__0" |
| // InternalGridSource.g:5727:1: rule__JvmUpperBound__Group__0 : rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 ; |
| public final void rule__JvmUpperBound__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5731:1: ( rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 ) |
| // InternalGridSource.g:5732:2: rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 |
| { |
| pushFollow(FOLLOW_6); |
| rule__JvmUpperBound__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmUpperBound__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmUpperBound__Group__0" |
| |
| |
| // $ANTLR start "rule__JvmUpperBound__Group__0__Impl" |
| // InternalGridSource.g:5739:1: rule__JvmUpperBound__Group__0__Impl : ( 'extends' ) ; |
| public final void rule__JvmUpperBound__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5743:1: ( ( 'extends' ) ) |
| // InternalGridSource.g:5744:1: ( 'extends' ) |
| { |
| // InternalGridSource.g:5744:1: ( 'extends' ) |
| // InternalGridSource.g:5745:2: 'extends' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); |
| } |
| match(input,66,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmUpperBound__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmUpperBound__Group__1" |
| // InternalGridSource.g:5754:1: rule__JvmUpperBound__Group__1 : rule__JvmUpperBound__Group__1__Impl ; |
| public final void rule__JvmUpperBound__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5758:1: ( rule__JvmUpperBound__Group__1__Impl ) |
| // InternalGridSource.g:5759:2: rule__JvmUpperBound__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmUpperBound__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmUpperBound__Group__1" |
| |
| |
| // $ANTLR start "rule__JvmUpperBound__Group__1__Impl" |
| // InternalGridSource.g:5765:1: rule__JvmUpperBound__Group__1__Impl : ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) ; |
| public final void rule__JvmUpperBound__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5769:1: ( ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) ) |
| // InternalGridSource.g:5770:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) |
| { |
| // InternalGridSource.g:5770:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) |
| // InternalGridSource.g:5771:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); |
| } |
| // InternalGridSource.g:5772:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) |
| // InternalGridSource.g:5772:3: rule__JvmUpperBound__TypeReferenceAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmUpperBound__TypeReferenceAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmUpperBound__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmUpperBoundAnded__Group__0" |
| // InternalGridSource.g:5781:1: rule__JvmUpperBoundAnded__Group__0 : rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 ; |
| public final void rule__JvmUpperBoundAnded__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5785:1: ( rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 ) |
| // InternalGridSource.g:5786:2: rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 |
| { |
| pushFollow(FOLLOW_6); |
| rule__JvmUpperBoundAnded__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmUpperBoundAnded__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmUpperBoundAnded__Group__0" |
| |
| |
| // $ANTLR start "rule__JvmUpperBoundAnded__Group__0__Impl" |
| // InternalGridSource.g:5793:1: rule__JvmUpperBoundAnded__Group__0__Impl : ( '&' ) ; |
| public final void rule__JvmUpperBoundAnded__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5797:1: ( ( '&' ) ) |
| // InternalGridSource.g:5798:1: ( '&' ) |
| { |
| // InternalGridSource.g:5798:1: ( '&' ) |
| // InternalGridSource.g:5799:2: '&' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); |
| } |
| match(input,67,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmUpperBoundAnded__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmUpperBoundAnded__Group__1" |
| // InternalGridSource.g:5808:1: rule__JvmUpperBoundAnded__Group__1 : rule__JvmUpperBoundAnded__Group__1__Impl ; |
| public final void rule__JvmUpperBoundAnded__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5812:1: ( rule__JvmUpperBoundAnded__Group__1__Impl ) |
| // InternalGridSource.g:5813:2: rule__JvmUpperBoundAnded__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmUpperBoundAnded__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmUpperBoundAnded__Group__1" |
| |
| |
| // $ANTLR start "rule__JvmUpperBoundAnded__Group__1__Impl" |
| // InternalGridSource.g:5819:1: rule__JvmUpperBoundAnded__Group__1__Impl : ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) ; |
| public final void rule__JvmUpperBoundAnded__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5823:1: ( ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) ) |
| // InternalGridSource.g:5824:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) |
| { |
| // InternalGridSource.g:5824:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) |
| // InternalGridSource.g:5825:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); |
| } |
| // InternalGridSource.g:5826:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) |
| // InternalGridSource.g:5826:3: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmUpperBoundAnded__TypeReferenceAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmUpperBoundAnded__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmLowerBound__Group__0" |
| // InternalGridSource.g:5835:1: rule__JvmLowerBound__Group__0 : rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 ; |
| public final void rule__JvmLowerBound__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5839:1: ( rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 ) |
| // InternalGridSource.g:5840:2: rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 |
| { |
| pushFollow(FOLLOW_6); |
| rule__JvmLowerBound__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmLowerBound__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmLowerBound__Group__0" |
| |
| |
| // $ANTLR start "rule__JvmLowerBound__Group__0__Impl" |
| // InternalGridSource.g:5847:1: rule__JvmLowerBound__Group__0__Impl : ( 'super' ) ; |
| public final void rule__JvmLowerBound__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5851:1: ( ( 'super' ) ) |
| // InternalGridSource.g:5852:1: ( 'super' ) |
| { |
| // InternalGridSource.g:5852:1: ( 'super' ) |
| // InternalGridSource.g:5853:2: 'super' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); |
| } |
| match(input,68,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmLowerBound__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmLowerBound__Group__1" |
| // InternalGridSource.g:5862:1: rule__JvmLowerBound__Group__1 : rule__JvmLowerBound__Group__1__Impl ; |
| public final void rule__JvmLowerBound__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5866:1: ( rule__JvmLowerBound__Group__1__Impl ) |
| // InternalGridSource.g:5867:2: rule__JvmLowerBound__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmLowerBound__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmLowerBound__Group__1" |
| |
| |
| // $ANTLR start "rule__JvmLowerBound__Group__1__Impl" |
| // InternalGridSource.g:5873:1: rule__JvmLowerBound__Group__1__Impl : ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) ; |
| public final void rule__JvmLowerBound__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5877:1: ( ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) ) |
| // InternalGridSource.g:5878:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) |
| { |
| // InternalGridSource.g:5878:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) |
| // InternalGridSource.g:5879:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); |
| } |
| // InternalGridSource.g:5880:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) |
| // InternalGridSource.g:5880:3: rule__JvmLowerBound__TypeReferenceAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmLowerBound__TypeReferenceAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmLowerBound__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__JvmLowerBoundAnded__Group__0" |
| // InternalGridSource.g:5889:1: rule__JvmLowerBoundAnded__Group__0 : rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 ; |
| public final void rule__JvmLowerBoundAnded__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5893:1: ( rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 ) |
| // InternalGridSource.g:5894:2: rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 |
| { |
| pushFollow(FOLLOW_6); |
| rule__JvmLowerBoundAnded__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__JvmLowerBoundAnded__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmLowerBoundAnded__Group__0" |
| |
| |
| // $ANTLR start "rule__JvmLowerBoundAnded__Group__0__Impl" |
| // InternalGridSource.g:5901:1: rule__JvmLowerBoundAnded__Group__0__Impl : ( '&' ) ; |
| public final void rule__JvmLowerBoundAnded__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5905:1: ( ( '&' ) ) |
| // InternalGridSource.g:5906:1: ( '&' ) |
| { |
| // InternalGridSource.g:5906:1: ( '&' ) |
| // InternalGridSource.g:5907:2: '&' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); |
| } |
| match(input,67,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmLowerBoundAnded__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__JvmLowerBoundAnded__Group__1" |
| // InternalGridSource.g:5916:1: rule__JvmLowerBoundAnded__Group__1 : rule__JvmLowerBoundAnded__Group__1__Impl ; |
| public final void rule__JvmLowerBoundAnded__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5920:1: ( rule__JvmLowerBoundAnded__Group__1__Impl ) |
| // InternalGridSource.g:5921:2: rule__JvmLowerBoundAnded__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmLowerBoundAnded__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmLowerBoundAnded__Group__1" |
| |
| |
| // $ANTLR start "rule__JvmLowerBoundAnded__Group__1__Impl" |
| // InternalGridSource.g:5927:1: rule__JvmLowerBoundAnded__Group__1__Impl : ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) ; |
| public final void rule__JvmLowerBoundAnded__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5931:1: ( ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) ) |
| // InternalGridSource.g:5932:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) |
| { |
| // InternalGridSource.g:5932:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) |
| // InternalGridSource.g:5933:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); |
| } |
| // InternalGridSource.g:5934:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) |
| // InternalGridSource.g:5934:3: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__JvmLowerBoundAnded__TypeReferenceAssignment_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmLowerBoundAnded__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0" |
| // InternalGridSource.g:5943:1: rule__QualifiedNameWithWildcard__Group__0 : rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 ; |
| public final void rule__QualifiedNameWithWildcard__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5947:1: ( rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 ) |
| // InternalGridSource.g:5948:2: rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 |
| { |
| pushFollow(FOLLOW_21); |
| rule__QualifiedNameWithWildcard__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__QualifiedNameWithWildcard__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0" |
| |
| |
| // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0__Impl" |
| // InternalGridSource.g:5955:1: rule__QualifiedNameWithWildcard__Group__0__Impl : ( ruleQualifiedName ) ; |
| public final void rule__QualifiedNameWithWildcard__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5959:1: ( ( ruleQualifiedName ) ) |
| // InternalGridSource.g:5960:1: ( ruleQualifiedName ) |
| { |
| // InternalGridSource.g:5960:1: ( ruleQualifiedName ) |
| // InternalGridSource.g:5961:2: ruleQualifiedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleQualifiedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1" |
| // InternalGridSource.g:5970:1: rule__QualifiedNameWithWildcard__Group__1 : rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 ; |
| public final void rule__QualifiedNameWithWildcard__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5974:1: ( rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 ) |
| // InternalGridSource.g:5975:2: rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 |
| { |
| pushFollow(FOLLOW_63); |
| rule__QualifiedNameWithWildcard__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__QualifiedNameWithWildcard__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1" |
| |
| |
| // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1__Impl" |
| // InternalGridSource.g:5982:1: rule__QualifiedNameWithWildcard__Group__1__Impl : ( '.' ) ; |
| public final void rule__QualifiedNameWithWildcard__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:5986:1: ( ( '.' ) ) |
| // InternalGridSource.g:5987:1: ( '.' ) |
| { |
| // InternalGridSource.g:5987:1: ( '.' ) |
| // InternalGridSource.g:5988:2: '.' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); |
| } |
| match(input,34,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2" |
| // InternalGridSource.g:5997:1: rule__QualifiedNameWithWildcard__Group__2 : rule__QualifiedNameWithWildcard__Group__2__Impl ; |
| public final void rule__QualifiedNameWithWildcard__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6001:1: ( rule__QualifiedNameWithWildcard__Group__2__Impl ) |
| // InternalGridSource.g:6002:2: rule__QualifiedNameWithWildcard__Group__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__QualifiedNameWithWildcard__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2" |
| |
| |
| // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2__Impl" |
| // InternalGridSource.g:6008:1: rule__QualifiedNameWithWildcard__Group__2__Impl : ( '*' ) ; |
| public final void rule__QualifiedNameWithWildcard__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6012:1: ( ( '*' ) ) |
| // InternalGridSource.g:6013:1: ( '*' ) |
| { |
| // InternalGridSource.g:6013:1: ( '*' ) |
| // InternalGridSource.g:6014:2: '*' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); |
| } |
| match(input,69,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group__0" |
| // InternalGridSource.g:6024:1: rule__XImportDeclaration__Group__0 : rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 ; |
| public final void rule__XImportDeclaration__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6028:1: ( rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 ) |
| // InternalGridSource.g:6029:2: rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 |
| { |
| pushFollow(FOLLOW_64); |
| rule__XImportDeclaration__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group__0" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group__0__Impl" |
| // InternalGridSource.g:6036:1: rule__XImportDeclaration__Group__0__Impl : ( 'import' ) ; |
| public final void rule__XImportDeclaration__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6040:1: ( ( 'import' ) ) |
| // InternalGridSource.g:6041:1: ( 'import' ) |
| { |
| // InternalGridSource.g:6041:1: ( 'import' ) |
| // InternalGridSource.g:6042:2: 'import' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); |
| } |
| match(input,70,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group__1" |
| // InternalGridSource.g:6051:1: rule__XImportDeclaration__Group__1 : rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 ; |
| public final void rule__XImportDeclaration__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6055:1: ( rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 ) |
| // InternalGridSource.g:6056:2: rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 |
| { |
| pushFollow(FOLLOW_65); |
| rule__XImportDeclaration__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__Group__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group__1" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group__1__Impl" |
| // InternalGridSource.g:6063:1: rule__XImportDeclaration__Group__1__Impl : ( ( rule__XImportDeclaration__Alternatives_1 ) ) ; |
| public final void rule__XImportDeclaration__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6067:1: ( ( ( rule__XImportDeclaration__Alternatives_1 ) ) ) |
| // InternalGridSource.g:6068:1: ( ( rule__XImportDeclaration__Alternatives_1 ) ) |
| { |
| // InternalGridSource.g:6068:1: ( ( rule__XImportDeclaration__Alternatives_1 ) ) |
| // InternalGridSource.g:6069:2: ( rule__XImportDeclaration__Alternatives_1 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); |
| } |
| // InternalGridSource.g:6070:2: ( rule__XImportDeclaration__Alternatives_1 ) |
| // InternalGridSource.g:6070:3: rule__XImportDeclaration__Alternatives_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__Alternatives_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group__2" |
| // InternalGridSource.g:6078:1: rule__XImportDeclaration__Group__2 : rule__XImportDeclaration__Group__2__Impl ; |
| public final void rule__XImportDeclaration__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6082:1: ( rule__XImportDeclaration__Group__2__Impl ) |
| // InternalGridSource.g:6083:2: rule__XImportDeclaration__Group__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__Group__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group__2" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group__2__Impl" |
| // InternalGridSource.g:6089:1: rule__XImportDeclaration__Group__2__Impl : ( ( ';' )? ) ; |
| public final void rule__XImportDeclaration__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6093:1: ( ( ( ';' )? ) ) |
| // InternalGridSource.g:6094:1: ( ( ';' )? ) |
| { |
| // InternalGridSource.g:6094:1: ( ( ';' )? ) |
| // InternalGridSource.g:6095:2: ( ';' )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); |
| } |
| // InternalGridSource.g:6096:2: ( ';' )? |
| int alt37=2; |
| int LA37_0 = input.LA(1); |
| |
| if ( (LA37_0==71) ) { |
| alt37=1; |
| } |
| switch (alt37) { |
| case 1 : |
| // InternalGridSource.g:6096:3: ';' |
| { |
| match(input,71,FOLLOW_2); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group_1_0__0" |
| // InternalGridSource.g:6105:1: rule__XImportDeclaration__Group_1_0__0 : rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 ; |
| public final void rule__XImportDeclaration__Group_1_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6109:1: ( rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 ) |
| // InternalGridSource.g:6110:2: rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 |
| { |
| pushFollow(FOLLOW_66); |
| rule__XImportDeclaration__Group_1_0__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__Group_1_0__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group_1_0__0" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group_1_0__0__Impl" |
| // InternalGridSource.g:6117:1: rule__XImportDeclaration__Group_1_0__0__Impl : ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) ; |
| public final void rule__XImportDeclaration__Group_1_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6121:1: ( ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) ) |
| // InternalGridSource.g:6122:1: ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) |
| { |
| // InternalGridSource.g:6122:1: ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) |
| // InternalGridSource.g:6123:2: ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); |
| } |
| // InternalGridSource.g:6124:2: ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) |
| // InternalGridSource.g:6124:3: rule__XImportDeclaration__StaticAssignment_1_0_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__StaticAssignment_1_0_0(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group_1_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group_1_0__1" |
| // InternalGridSource.g:6132:1: rule__XImportDeclaration__Group_1_0__1 : rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 ; |
| public final void rule__XImportDeclaration__Group_1_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6136:1: ( rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 ) |
| // InternalGridSource.g:6137:2: rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 |
| { |
| pushFollow(FOLLOW_66); |
| rule__XImportDeclaration__Group_1_0__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__Group_1_0__2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group_1_0__1" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group_1_0__1__Impl" |
| // InternalGridSource.g:6144:1: rule__XImportDeclaration__Group_1_0__1__Impl : ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) ; |
| public final void rule__XImportDeclaration__Group_1_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6148:1: ( ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) ) |
| // InternalGridSource.g:6149:1: ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) |
| { |
| // InternalGridSource.g:6149:1: ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) |
| // InternalGridSource.g:6150:2: ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); |
| } |
| // InternalGridSource.g:6151:2: ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? |
| int alt38=2; |
| int LA38_0 = input.LA(1); |
| |
| if ( (LA38_0==73) ) { |
| alt38=1; |
| } |
| switch (alt38) { |
| case 1 : |
| // InternalGridSource.g:6151:3: rule__XImportDeclaration__ExtensionAssignment_1_0_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__ExtensionAssignment_1_0_1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group_1_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group_1_0__2" |
| // InternalGridSource.g:6159:1: rule__XImportDeclaration__Group_1_0__2 : rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 ; |
| public final void rule__XImportDeclaration__Group_1_0__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6163:1: ( rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 ) |
| // InternalGridSource.g:6164:2: rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 |
| { |
| pushFollow(FOLLOW_67); |
| rule__XImportDeclaration__Group_1_0__2__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__Group_1_0__3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group_1_0__2" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group_1_0__2__Impl" |
| // InternalGridSource.g:6171:1: rule__XImportDeclaration__Group_1_0__2__Impl : ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) ; |
| public final void rule__XImportDeclaration__Group_1_0__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6175:1: ( ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) ) |
| // InternalGridSource.g:6176:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) |
| { |
| // InternalGridSource.g:6176:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) |
| // InternalGridSource.g:6177:2: ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); |
| } |
| // InternalGridSource.g:6178:2: ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) |
| // InternalGridSource.g:6178:3: rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__ImportedTypeAssignment_1_0_2(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group_1_0__2__Impl" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group_1_0__3" |
| // InternalGridSource.g:6186:1: rule__XImportDeclaration__Group_1_0__3 : rule__XImportDeclaration__Group_1_0__3__Impl ; |
| public final void rule__XImportDeclaration__Group_1_0__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6190:1: ( rule__XImportDeclaration__Group_1_0__3__Impl ) |
| // InternalGridSource.g:6191:2: rule__XImportDeclaration__Group_1_0__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__Group_1_0__3__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group_1_0__3" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__Group_1_0__3__Impl" |
| // InternalGridSource.g:6197:1: rule__XImportDeclaration__Group_1_0__3__Impl : ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) ; |
| public final void rule__XImportDeclaration__Group_1_0__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6201:1: ( ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) ) |
| // InternalGridSource.g:6202:1: ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) |
| { |
| // InternalGridSource.g:6202:1: ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) |
| // InternalGridSource.g:6203:2: ( rule__XImportDeclaration__Alternatives_1_0_3 ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); |
| } |
| // InternalGridSource.g:6204:2: ( rule__XImportDeclaration__Alternatives_1_0_3 ) |
| // InternalGridSource.g:6204:3: rule__XImportDeclaration__Alternatives_1_0_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__XImportDeclaration__Alternatives_1_0_3(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__Group_1_0__3__Impl" |
| |
| |
| // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0" |
| // InternalGridSource.g:6213:1: rule__QualifiedNameInStaticImport__Group__0 : rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 ; |
| public final void rule__QualifiedNameInStaticImport__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6217:1: ( rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 ) |
| // InternalGridSource.g:6218:2: rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 |
| { |
| pushFollow(FOLLOW_21); |
| rule__QualifiedNameInStaticImport__Group__0__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| pushFollow(FOLLOW_2); |
| rule__QualifiedNameInStaticImport__Group__1(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0" |
| |
| |
| // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0__Impl" |
| // InternalGridSource.g:6225:1: rule__QualifiedNameInStaticImport__Group__0__Impl : ( ruleValidID ) ; |
| public final void rule__QualifiedNameInStaticImport__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6229:1: ( ( ruleValidID ) ) |
| // InternalGridSource.g:6230:1: ( ruleValidID ) |
| { |
| // InternalGridSource.g:6230:1: ( ruleValidID ) |
| // InternalGridSource.g:6231:2: ruleValidID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleValidID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1" |
| // InternalGridSource.g:6240:1: rule__QualifiedNameInStaticImport__Group__1 : rule__QualifiedNameInStaticImport__Group__1__Impl ; |
| public final void rule__QualifiedNameInStaticImport__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6244:1: ( rule__QualifiedNameInStaticImport__Group__1__Impl ) |
| // InternalGridSource.g:6245:2: rule__QualifiedNameInStaticImport__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__QualifiedNameInStaticImport__Group__1__Impl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1" |
| |
| |
| // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1__Impl" |
| // InternalGridSource.g:6251:1: rule__QualifiedNameInStaticImport__Group__1__Impl : ( '.' ) ; |
| public final void rule__QualifiedNameInStaticImport__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6255:1: ( ( '.' ) ) |
| // InternalGridSource.g:6256:1: ( '.' ) |
| { |
| // InternalGridSource.g:6256:1: ( '.' ) |
| // InternalGridSource.g:6257:2: '.' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); |
| } |
| match(input,34,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Source__IdAssignment_1" |
| // InternalGridSource.g:6267:1: rule__Source__IdAssignment_1 : ( ruleQualifiedName ) ; |
| public final void rule__Source__IdAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6271:1: ( ( ruleQualifiedName ) ) |
| // InternalGridSource.g:6272:2: ( ruleQualifiedName ) |
| { |
| // InternalGridSource.g:6272:2: ( ruleQualifiedName ) |
| // InternalGridSource.g:6273:3: ruleQualifiedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getIdQualifiedNameParserRuleCall_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleQualifiedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getIdQualifiedNameParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__IdAssignment_1" |
| |
| |
| // $ANTLR start "rule__Source__RootTypeAssignment_3" |
| // InternalGridSource.g:6282:1: rule__Source__RootTypeAssignment_3 : ( ruleJvmTypeReference ) ; |
| public final void rule__Source__RootTypeAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6286:1: ( ( ruleJvmTypeReference ) ) |
| // InternalGridSource.g:6287:2: ( ruleJvmTypeReference ) |
| { |
| // InternalGridSource.g:6287:2: ( ruleJvmTypeReference ) |
| // InternalGridSource.g:6288:3: ruleJvmTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getRootTypeJvmTypeReferenceParserRuleCall_3_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getRootTypeJvmTypeReferenceParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__RootTypeAssignment_3" |
| |
| |
| // $ANTLR start "rule__Source__InputsAssignment_7" |
| // InternalGridSource.g:6297:1: rule__Source__InputsAssignment_7 : ( ruleInput ) ; |
| public final void rule__Source__InputsAssignment_7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6301:1: ( ( ruleInput ) ) |
| // InternalGridSource.g:6302:2: ( ruleInput ) |
| { |
| // InternalGridSource.g:6302:2: ( ruleInput ) |
| // InternalGridSource.g:6303:3: ruleInput |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getInputsInputParserRuleCall_7_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleInput(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getInputsInputParserRuleCall_7_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__InputsAssignment_7" |
| |
| |
| // $ANTLR start "rule__Source__PropertiesAssignment_9" |
| // InternalGridSource.g:6312:1: rule__Source__PropertiesAssignment_9 : ( ruleProperty ) ; |
| public final void rule__Source__PropertiesAssignment_9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6316:1: ( ( ruleProperty ) ) |
| // InternalGridSource.g:6317:2: ( ruleProperty ) |
| { |
| // InternalGridSource.g:6317:2: ( ruleProperty ) |
| // InternalGridSource.g:6318:3: ruleProperty |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getSourceAccess().getPropertiesPropertyParserRuleCall_9_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleProperty(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getSourceAccess().getPropertiesPropertyParserRuleCall_9_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Source__PropertiesAssignment_9" |
| |
| |
| // $ANTLR start "rule__Input__InputTypeAssignment_1" |
| // InternalGridSource.g:6327:1: rule__Input__InputTypeAssignment_1 : ( ruleJvmTypeReference ) ; |
| public final void rule__Input__InputTypeAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6331:1: ( ( ruleJvmTypeReference ) ) |
| // InternalGridSource.g:6332:2: ( ruleJvmTypeReference ) |
| { |
| // InternalGridSource.g:6332:2: ( ruleJvmTypeReference ) |
| // InternalGridSource.g:6333:3: ruleJvmTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputAccess().getInputTypeJvmTypeReferenceParserRuleCall_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputAccess().getInputTypeJvmTypeReferenceParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__InputTypeAssignment_1" |
| |
| |
| // $ANTLR start "rule__Input__FiltersAssignment_3" |
| // InternalGridSource.g:6342:1: rule__Input__FiltersAssignment_3 : ( ruleEQFilter ) ; |
| public final void rule__Input__FiltersAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6346:1: ( ( ruleEQFilter ) ) |
| // InternalGridSource.g:6347:2: ( ruleEQFilter ) |
| { |
| // InternalGridSource.g:6347:2: ( ruleEQFilter ) |
| // InternalGridSource.g:6348:3: ruleEQFilter |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputAccess().getFiltersEQFilterParserRuleCall_3_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleEQFilter(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputAccess().getFiltersEQFilterParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__FiltersAssignment_3" |
| |
| |
| // $ANTLR start "rule__Input__FiltersAssignment_4_1" |
| // InternalGridSource.g:6357:1: rule__Input__FiltersAssignment_4_1 : ( ruleEQFilter ) ; |
| public final void rule__Input__FiltersAssignment_4_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6361:1: ( ( ruleEQFilter ) ) |
| // InternalGridSource.g:6362:2: ( ruleEQFilter ) |
| { |
| // InternalGridSource.g:6362:2: ( ruleEQFilter ) |
| // InternalGridSource.g:6363:3: ruleEQFilter |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getInputAccess().getFiltersEQFilterParserRuleCall_4_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleEQFilter(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getInputAccess().getFiltersEQFilterParserRuleCall_4_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Input__FiltersAssignment_4_1" |
| |
| |
| // $ANTLR start "rule__EQFilter__RootTypePropertyPathAssignment_2" |
| // InternalGridSource.g:6372:1: rule__EQFilter__RootTypePropertyPathAssignment_2 : ( ruleNestedField ) ; |
| public final void rule__EQFilter__RootTypePropertyPathAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6376:1: ( ( ruleNestedField ) ) |
| // InternalGridSource.g:6377:2: ( ruleNestedField ) |
| { |
| // InternalGridSource.g:6377:2: ( ruleNestedField ) |
| // InternalGridSource.g:6378:3: ruleNestedField |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEQFilterAccess().getRootTypePropertyPathNestedFieldParserRuleCall_2_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleNestedField(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEQFilterAccess().getRootTypePropertyPathNestedFieldParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__RootTypePropertyPathAssignment_2" |
| |
| |
| // $ANTLR start "rule__EQFilter__InputTypePropertyPathAssignment_5" |
| // InternalGridSource.g:6387:1: rule__EQFilter__InputTypePropertyPathAssignment_5 : ( ruleNestedField ) ; |
| public final void rule__EQFilter__InputTypePropertyPathAssignment_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6391:1: ( ( ruleNestedField ) ) |
| // InternalGridSource.g:6392:2: ( ruleNestedField ) |
| { |
| // InternalGridSource.g:6392:2: ( ruleNestedField ) |
| // InternalGridSource.g:6393:3: ruleNestedField |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getEQFilterAccess().getInputTypePropertyPathNestedFieldParserRuleCall_5_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleNestedField(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getEQFilterAccess().getInputTypePropertyPathNestedFieldParserRuleCall_5_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EQFilter__InputTypePropertyPathAssignment_5" |
| |
| |
| // $ANTLR start "rule__Property__PathAssignment_1" |
| // InternalGridSource.g:6402:1: rule__Property__PathAssignment_1 : ( ruleNestedField ) ; |
| public final void rule__Property__PathAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6406:1: ( ( ruleNestedField ) ) |
| // InternalGridSource.g:6407:2: ( ruleNestedField ) |
| { |
| // InternalGridSource.g:6407:2: ( ruleNestedField ) |
| // InternalGridSource.g:6408:3: ruleNestedField |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyAccess().getPathNestedFieldParserRuleCall_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleNestedField(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyAccess().getPathNestedFieldParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Property__PathAssignment_1" |
| |
| |
| // $ANTLR start "rule__Property__StyleAssignment_3" |
| // InternalGridSource.g:6417:1: rule__Property__StyleAssignment_3 : ( rulePropertyStyle ) ; |
| public final void rule__Property__StyleAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6421:1: ( ( rulePropertyStyle ) ) |
| // InternalGridSource.g:6422:2: ( rulePropertyStyle ) |
| { |
| // InternalGridSource.g:6422:2: ( rulePropertyStyle ) |
| // InternalGridSource.g:6423:3: rulePropertyStyle |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyAccess().getStylePropertyStyleParserRuleCall_3_0()); |
| } |
| pushFollow(FOLLOW_2); |
| rulePropertyStyle(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyAccess().getStylePropertyStyleParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Property__StyleAssignment_3" |
| |
| |
| // $ANTLR start "rule__NestedField__FieldAssignment_1" |
| // InternalGridSource.g:6432:1: rule__NestedField__FieldAssignment_1 : ( ( RULE_ID ) ) ; |
| public final void rule__NestedField__FieldAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6436:1: ( ( ( RULE_ID ) ) ) |
| // InternalGridSource.g:6437:2: ( ( RULE_ID ) ) |
| { |
| // InternalGridSource.g:6437:2: ( ( RULE_ID ) ) |
| // InternalGridSource.g:6438:3: ( RULE_ID ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedFieldAccess().getFieldJvmOperationCrossReference_1_0()); |
| } |
| // InternalGridSource.g:6439:3: ( RULE_ID ) |
| // InternalGridSource.g:6440:4: RULE_ID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedFieldAccess().getFieldJvmOperationIDTerminalRuleCall_1_0_1()); |
| } |
| match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedFieldAccess().getFieldJvmOperationIDTerminalRuleCall_1_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedFieldAccess().getFieldJvmOperationCrossReference_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedField__FieldAssignment_1" |
| |
| |
| // $ANTLR start "rule__NestedField__PathAssignment_2" |
| // InternalGridSource.g:6451:1: rule__NestedField__PathAssignment_2 : ( ruleNestedPath ) ; |
| public final void rule__NestedField__PathAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6455:1: ( ( ruleNestedPath ) ) |
| // InternalGridSource.g:6456:2: ( ruleNestedPath ) |
| { |
| // InternalGridSource.g:6456:2: ( ruleNestedPath ) |
| // InternalGridSource.g:6457:3: ruleNestedPath |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedFieldAccess().getPathNestedPathParserRuleCall_2_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleNestedPath(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedFieldAccess().getPathNestedPathParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedField__PathAssignment_2" |
| |
| |
| // $ANTLR start "rule__NestedPath__FieldAssignment_2" |
| // InternalGridSource.g:6466:1: rule__NestedPath__FieldAssignment_2 : ( ( RULE_ID ) ) ; |
| public final void rule__NestedPath__FieldAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6470:1: ( ( ( RULE_ID ) ) ) |
| // InternalGridSource.g:6471:2: ( ( RULE_ID ) ) |
| { |
| // InternalGridSource.g:6471:2: ( ( RULE_ID ) ) |
| // InternalGridSource.g:6472:3: ( RULE_ID ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedPathAccess().getFieldJvmOperationCrossReference_2_0()); |
| } |
| // InternalGridSource.g:6473:3: ( RULE_ID ) |
| // InternalGridSource.g:6474:4: RULE_ID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedPathAccess().getFieldJvmOperationIDTerminalRuleCall_2_0_1()); |
| } |
| match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedPathAccess().getFieldJvmOperationIDTerminalRuleCall_2_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedPathAccess().getFieldJvmOperationCrossReference_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedPath__FieldAssignment_2" |
| |
| |
| // $ANTLR start "rule__NestedPath__PathAssignment_3" |
| // InternalGridSource.g:6485:1: rule__NestedPath__PathAssignment_3 : ( ruleNestedPath ) ; |
| public final void rule__NestedPath__PathAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6489:1: ( ( ruleNestedPath ) ) |
| // InternalGridSource.g:6490:2: ( ruleNestedPath ) |
| { |
| // InternalGridSource.g:6490:2: ( ruleNestedPath ) |
| // InternalGridSource.g:6491:3: ruleNestedPath |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNestedPathAccess().getPathNestedPathParserRuleCall_3_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleNestedPath(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNestedPathAccess().getPathNestedPathParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NestedPath__PathAssignment_3" |
| |
| |
| // $ANTLR start "rule__PropertyButtonStyle__EventTopicAssignment_3" |
| // InternalGridSource.g:6500:1: rule__PropertyButtonStyle__EventTopicAssignment_3 : ( RULE_STRING ) ; |
| public final void rule__PropertyButtonStyle__EventTopicAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6504:1: ( ( RULE_STRING ) ) |
| // InternalGridSource.g:6505:2: ( RULE_STRING ) |
| { |
| // InternalGridSource.g:6505:2: ( RULE_STRING ) |
| // InternalGridSource.g:6506:3: RULE_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyButtonStyleAccess().getEventTopicSTRINGTerminalRuleCall_3_0()); |
| } |
| match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyButtonStyleAccess().getEventTopicSTRINGTerminalRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyButtonStyle__EventTopicAssignment_3" |
| |
| |
| // $ANTLR start "rule__PropertyDateStyle__DateFormatAssignment_3" |
| // InternalGridSource.g:6515:1: rule__PropertyDateStyle__DateFormatAssignment_3 : ( RULE_STRING ) ; |
| public final void rule__PropertyDateStyle__DateFormatAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6519:1: ( ( RULE_STRING ) ) |
| // InternalGridSource.g:6520:2: ( RULE_STRING ) |
| { |
| // InternalGridSource.g:6520:2: ( RULE_STRING ) |
| // InternalGridSource.g:6521:3: RULE_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyDateStyleAccess().getDateFormatSTRINGTerminalRuleCall_3_0()); |
| } |
| match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyDateStyleAccess().getDateFormatSTRINGTerminalRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyDateStyle__DateFormatAssignment_3" |
| |
| |
| // $ANTLR start "rule__PropertyNumberStyle__NumberFormatAssignment_3" |
| // InternalGridSource.g:6530:1: rule__PropertyNumberStyle__NumberFormatAssignment_3 : ( RULE_STRING ) ; |
| public final void rule__PropertyNumberStyle__NumberFormatAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6534:1: ( ( RULE_STRING ) ) |
| // InternalGridSource.g:6535:2: ( RULE_STRING ) |
| { |
| // InternalGridSource.g:6535:2: ( RULE_STRING ) |
| // InternalGridSource.g:6536:3: RULE_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyNumberStyleAccess().getNumberFormatSTRINGTerminalRuleCall_3_0()); |
| } |
| match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyNumberStyleAccess().getNumberFormatSTRINGTerminalRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyNumberStyle__NumberFormatAssignment_3" |
| |
| |
| // $ANTLR start "rule__PropertyProgressbarStyle__MaxValueAssignment_3" |
| // InternalGridSource.g:6545:1: rule__PropertyProgressbarStyle__MaxValueAssignment_3 : ( ruleLDouble ) ; |
| public final void rule__PropertyProgressbarStyle__MaxValueAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6549:1: ( ( ruleLDouble ) ) |
| // InternalGridSource.g:6550:2: ( ruleLDouble ) |
| { |
| // InternalGridSource.g:6550:2: ( ruleLDouble ) |
| // InternalGridSource.g:6551:3: ruleLDouble |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyProgressbarStyleAccess().getMaxValueLDoubleParserRuleCall_3_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleLDouble(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyProgressbarStyleAccess().getMaxValueLDoubleParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyProgressbarStyle__MaxValueAssignment_3" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__GreenStartsAssignment_3" |
| // InternalGridSource.g:6560:1: rule__GridPropIndicatorStyle__GreenStartsAssignment_3 : ( ruleLDouble ) ; |
| public final void rule__GridPropIndicatorStyle__GreenStartsAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6564:1: ( ( ruleLDouble ) ) |
| // InternalGridSource.g:6565:2: ( ruleLDouble ) |
| { |
| // InternalGridSource.g:6565:2: ( ruleLDouble ) |
| // InternalGridSource.g:6566:3: ruleLDouble |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getGridPropIndicatorStyleAccess().getGreenStartsLDoubleParserRuleCall_3_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleLDouble(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getGridPropIndicatorStyleAccess().getGreenStartsLDoubleParserRuleCall_3_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__GreenStartsAssignment_3" |
| |
| |
| // $ANTLR start "rule__GridPropIndicatorStyle__RedEndsAssignment_5" |
| // InternalGridSource.g:6575:1: rule__GridPropIndicatorStyle__RedEndsAssignment_5 : ( ruleLDouble ) ; |
| public final void rule__GridPropIndicatorStyle__RedEndsAssignment_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6579:1: ( ( ruleLDouble ) ) |
| // InternalGridSource.g:6580:2: ( ruleLDouble ) |
| { |
| // InternalGridSource.g:6580:2: ( ruleLDouble ) |
| // InternalGridSource.g:6581:3: ruleLDouble |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getGridPropIndicatorStyleAccess().getRedEndsLDoubleParserRuleCall_5_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleLDouble(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getGridPropIndicatorStyleAccess().getRedEndsLDoubleParserRuleCall_5_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GridPropIndicatorStyle__RedEndsAssignment_5" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__HtmlPatternAssignment_2" |
| // InternalGridSource.g:6590:1: rule__PropertyQuantityStyle__HtmlPatternAssignment_2 : ( RULE_STRING ) ; |
| public final void rule__PropertyQuantityStyle__HtmlPatternAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6594:1: ( ( RULE_STRING ) ) |
| // InternalGridSource.g:6595:2: ( RULE_STRING ) |
| { |
| // InternalGridSource.g:6595:2: ( RULE_STRING ) |
| // InternalGridSource.g:6596:3: RULE_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getHtmlPatternSTRINGTerminalRuleCall_2_0()); |
| } |
| match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getHtmlPatternSTRINGTerminalRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__HtmlPatternAssignment_2" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5" |
| // InternalGridSource.g:6605:1: rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5 : ( ruleNestedField ) ; |
| public final void rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6609:1: ( ( ruleNestedField ) ) |
| // InternalGridSource.g:6610:2: ( ruleNestedField ) |
| { |
| // InternalGridSource.g:6610:2: ( ruleNestedField ) |
| // InternalGridSource.g:6611:3: ruleNestedField |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getValuePropertyPathNestedFieldParserRuleCall_5_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleNestedField(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getValuePropertyPathNestedFieldParserRuleCall_5_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__ValuePropertyPathAssignment_5" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2" |
| // InternalGridSource.g:6620:1: rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2 : ( RULE_STRING ) ; |
| public final void rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6624:1: ( ( RULE_STRING ) ) |
| // InternalGridSource.g:6625:2: ( RULE_STRING ) |
| { |
| // InternalGridSource.g:6625:2: ( RULE_STRING ) |
| // InternalGridSource.g:6626:3: RULE_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getValueNumberFormatSTRINGTerminalRuleCall_6_2_0()); |
| } |
| match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getValueNumberFormatSTRINGTerminalRuleCall_6_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__ValueNumberFormatAssignment_6_2" |
| |
| |
| // $ANTLR start "rule__PropertyQuantityStyle__UomPropertyPathAssignment_9" |
| // InternalGridSource.g:6635:1: rule__PropertyQuantityStyle__UomPropertyPathAssignment_9 : ( ruleNestedField ) ; |
| public final void rule__PropertyQuantityStyle__UomPropertyPathAssignment_9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6639:1: ( ( ruleNestedField ) ) |
| // InternalGridSource.g:6640:2: ( ruleNestedField ) |
| { |
| // InternalGridSource.g:6640:2: ( ruleNestedField ) |
| // InternalGridSource.g:6641:3: ruleNestedField |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyQuantityStyleAccess().getUomPropertyPathNestedFieldParserRuleCall_9_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleNestedField(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyQuantityStyleAccess().getUomPropertyPathNestedFieldParserRuleCall_9_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyQuantityStyle__UomPropertyPathAssignment_9" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__HtmlPatternAssignment_2" |
| // InternalGridSource.g:6650:1: rule__PropertyPriceStyle__HtmlPatternAssignment_2 : ( RULE_STRING ) ; |
| public final void rule__PropertyPriceStyle__HtmlPatternAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6654:1: ( ( RULE_STRING ) ) |
| // InternalGridSource.g:6655:2: ( RULE_STRING ) |
| { |
| // InternalGridSource.g:6655:2: ( RULE_STRING ) |
| // InternalGridSource.g:6656:3: RULE_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getHtmlPatternSTRINGTerminalRuleCall_2_0()); |
| } |
| match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getHtmlPatternSTRINGTerminalRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__HtmlPatternAssignment_2" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__ValuePropertyPathAssignment_5" |
| // InternalGridSource.g:6665:1: rule__PropertyPriceStyle__ValuePropertyPathAssignment_5 : ( ruleNestedField ) ; |
| public final void rule__PropertyPriceStyle__ValuePropertyPathAssignment_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6669:1: ( ( ruleNestedField ) ) |
| // InternalGridSource.g:6670:2: ( ruleNestedField ) |
| { |
| // InternalGridSource.g:6670:2: ( ruleNestedField ) |
| // InternalGridSource.g:6671:3: ruleNestedField |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getValuePropertyPathNestedFieldParserRuleCall_5_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleNestedField(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getValuePropertyPathNestedFieldParserRuleCall_5_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__ValuePropertyPathAssignment_5" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2" |
| // InternalGridSource.g:6680:1: rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2 : ( RULE_STRING ) ; |
| public final void rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6684:1: ( ( RULE_STRING ) ) |
| // InternalGridSource.g:6685:2: ( RULE_STRING ) |
| { |
| // InternalGridSource.g:6685:2: ( RULE_STRING ) |
| // InternalGridSource.g:6686:3: RULE_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getValueNumberFormatSTRINGTerminalRuleCall_6_2_0()); |
| } |
| match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getValueNumberFormatSTRINGTerminalRuleCall_6_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__ValueNumberFormatAssignment_6_2" |
| |
| |
| // $ANTLR start "rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9" |
| // InternalGridSource.g:6695:1: rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9 : ( ruleNestedField ) ; |
| public final void rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6699:1: ( ( ruleNestedField ) ) |
| // InternalGridSource.g:6700:2: ( ruleNestedField ) |
| { |
| // InternalGridSource.g:6700:2: ( ruleNestedField ) |
| // InternalGridSource.g:6701:3: ruleNestedField |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyPriceStyleAccess().getCurrencyPropertyPathNestedFieldParserRuleCall_9_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleNestedField(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyPriceStyleAccess().getCurrencyPropertyPathNestedFieldParserRuleCall_9_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyPriceStyle__CurrencyPropertyPathAssignment_9" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__EventTopicAssignment_2_1" |
| // InternalGridSource.g:6710:1: rule__PropertyImageStyle__EventTopicAssignment_2_1 : ( RULE_STRING ) ; |
| public final void rule__PropertyImageStyle__EventTopicAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6714:1: ( ( RULE_STRING ) ) |
| // InternalGridSource.g:6715:2: ( RULE_STRING ) |
| { |
| // InternalGridSource.g:6715:2: ( RULE_STRING ) |
| // InternalGridSource.g:6716:3: RULE_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleAccess().getEventTopicSTRINGTerminalRuleCall_2_1_0()); |
| } |
| match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleAccess().getEventTopicSTRINGTerminalRuleCall_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__EventTopicAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__PropertyImageStyle__ConfigsAssignment_4" |
| // InternalGridSource.g:6725:1: rule__PropertyImageStyle__ConfigsAssignment_4 : ( ruleStyleConfig ) ; |
| public final void rule__PropertyImageStyle__ConfigsAssignment_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6729:1: ( ( ruleStyleConfig ) ) |
| // InternalGridSource.g:6730:2: ( ruleStyleConfig ) |
| { |
| // InternalGridSource.g:6730:2: ( ruleStyleConfig ) |
| // InternalGridSource.g:6731:3: ruleStyleConfig |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getPropertyImageStyleAccess().getConfigsStyleConfigParserRuleCall_4_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleStyleConfig(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getPropertyImageStyleAccess().getConfigsStyleConfigParserRuleCall_4_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__PropertyImageStyle__ConfigsAssignment_4" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__CompareAssignment_1" |
| // InternalGridSource.g:6740:1: rule__NumericToResourceStyleConfig__CompareAssignment_1 : ( ruleStyleCompare ) ; |
| public final void rule__NumericToResourceStyleConfig__CompareAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6744:1: ( ( ruleStyleCompare ) ) |
| // InternalGridSource.g:6745:2: ( ruleStyleCompare ) |
| { |
| // InternalGridSource.g:6745:2: ( ruleStyleCompare ) |
| // InternalGridSource.g:6746:3: ruleStyleCompare |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumericToResourceStyleConfigAccess().getCompareStyleCompareEnumRuleCall_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleStyleCompare(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumericToResourceStyleConfigAccess().getCompareStyleCompareEnumRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__CompareAssignment_1" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__ValueAssignment_2" |
| // InternalGridSource.g:6755:1: rule__NumericToResourceStyleConfig__ValueAssignment_2 : ( ruleLDouble ) ; |
| public final void rule__NumericToResourceStyleConfig__ValueAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6759:1: ( ( ruleLDouble ) ) |
| // InternalGridSource.g:6760:2: ( ruleLDouble ) |
| { |
| // InternalGridSource.g:6760:2: ( ruleLDouble ) |
| // InternalGridSource.g:6761:3: ruleLDouble |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumericToResourceStyleConfigAccess().getValueLDoubleParserRuleCall_2_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleLDouble(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumericToResourceStyleConfigAccess().getValueLDoubleParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__ValueAssignment_2" |
| |
| |
| // $ANTLR start "rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4" |
| // InternalGridSource.g:6770:1: rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4 : ( RULE_THEME_RESOURCE ) ; |
| public final void rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6774:1: ( ( RULE_THEME_RESOURCE ) ) |
| // InternalGridSource.g:6775:2: ( RULE_THEME_RESOURCE ) |
| { |
| // InternalGridSource.g:6775:2: ( RULE_THEME_RESOURCE ) |
| // InternalGridSource.g:6776:3: RULE_THEME_RESOURCE |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getNumericToResourceStyleConfigAccess().getResourceThemePathTHEME_RESOURCETerminalRuleCall_4_0()); |
| } |
| match(input,RULE_THEME_RESOURCE,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getNumericToResourceStyleConfigAccess().getResourceThemePathTHEME_RESOURCETerminalRuleCall_4_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumericToResourceStyleConfig__ResourceThemePathAssignment_4" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__CompareAssignment_1" |
| // InternalGridSource.g:6785:1: rule__StringToResourceStyleConfig__CompareAssignment_1 : ( ruleStyleCompare ) ; |
| public final void rule__StringToResourceStyleConfig__CompareAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6789:1: ( ( ruleStyleCompare ) ) |
| // InternalGridSource.g:6790:2: ( ruleStyleCompare ) |
| { |
| // InternalGridSource.g:6790:2: ( ruleStyleCompare ) |
| // InternalGridSource.g:6791:3: ruleStyleCompare |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringToResourceStyleConfigAccess().getCompareStyleCompareEnumRuleCall_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleStyleCompare(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringToResourceStyleConfigAccess().getCompareStyleCompareEnumRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__CompareAssignment_1" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__ValueAssignment_2" |
| // InternalGridSource.g:6800:1: rule__StringToResourceStyleConfig__ValueAssignment_2 : ( RULE_STRING ) ; |
| public final void rule__StringToResourceStyleConfig__ValueAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6804:1: ( ( RULE_STRING ) ) |
| // InternalGridSource.g:6805:2: ( RULE_STRING ) |
| { |
| // InternalGridSource.g:6805:2: ( RULE_STRING ) |
| // InternalGridSource.g:6806:3: RULE_STRING |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringToResourceStyleConfigAccess().getValueSTRINGTerminalRuleCall_2_0()); |
| } |
| match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringToResourceStyleConfigAccess().getValueSTRINGTerminalRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__ValueAssignment_2" |
| |
| |
| // $ANTLR start "rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4" |
| // InternalGridSource.g:6815:1: rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4 : ( RULE_THEME_RESOURCE ) ; |
| public final void rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6819:1: ( ( RULE_THEME_RESOURCE ) ) |
| // InternalGridSource.g:6820:2: ( RULE_THEME_RESOURCE ) |
| { |
| // InternalGridSource.g:6820:2: ( RULE_THEME_RESOURCE ) |
| // InternalGridSource.g:6821:3: RULE_THEME_RESOURCE |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getStringToResourceStyleConfigAccess().getResourceThemePathTHEME_RESOURCETerminalRuleCall_4_0()); |
| } |
| match(input,RULE_THEME_RESOURCE,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getStringToResourceStyleConfigAccess().getResourceThemePathTHEME_RESOURCETerminalRuleCall_4_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringToResourceStyleConfig__ResourceThemePathAssignment_4" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0" |
| // InternalGridSource.g:6830:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 : ( ruleJvmTypeReference ) ; |
| public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6834:1: ( ( ruleJvmTypeReference ) ) |
| // InternalGridSource.g:6835:2: ( ruleJvmTypeReference ) |
| { |
| // InternalGridSource.g:6835:2: ( ruleJvmTypeReference ) |
| // InternalGridSource.g:6836:3: ruleJvmTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1" |
| // InternalGridSource.g:6845:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 : ( ruleJvmTypeReference ) ; |
| public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6849:1: ( ( ruleJvmTypeReference ) ) |
| // InternalGridSource.g:6850:2: ( ruleJvmTypeReference ) |
| { |
| // InternalGridSource.g:6850:2: ( ruleJvmTypeReference ) |
| // InternalGridSource.g:6851:3: ruleJvmTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1" |
| |
| |
| // $ANTLR start "rule__XFunctionTypeRef__ReturnTypeAssignment_2" |
| // InternalGridSource.g:6860:1: rule__XFunctionTypeRef__ReturnTypeAssignment_2 : ( ruleJvmTypeReference ) ; |
| public final void rule__XFunctionTypeRef__ReturnTypeAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6864:1: ( ( ruleJvmTypeReference ) ) |
| // InternalGridSource.g:6865:2: ( ruleJvmTypeReference ) |
| { |
| // InternalGridSource.g:6865:2: ( ruleJvmTypeReference ) |
| // InternalGridSource.g:6866:3: ruleJvmTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XFunctionTypeRef__ReturnTypeAssignment_2" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_0" |
| // InternalGridSource.g:6875:1: rule__JvmParameterizedTypeReference__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ; |
| public final void rule__JvmParameterizedTypeReference__TypeAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6879:1: ( ( ( ruleQualifiedName ) ) ) |
| // InternalGridSource.g:6880:2: ( ( ruleQualifiedName ) ) |
| { |
| // InternalGridSource.g:6880:2: ( ( ruleQualifiedName ) ) |
| // InternalGridSource.g:6881:3: ( ruleQualifiedName ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); |
| } |
| // InternalGridSource.g:6882:3: ( ruleQualifiedName ) |
| // InternalGridSource.g:6883:4: ruleQualifiedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleQualifiedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_0" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1" |
| // InternalGridSource.g:6894:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 : ( ruleJvmArgumentTypeReference ) ; |
| public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6898:1: ( ( ruleJvmArgumentTypeReference ) ) |
| // InternalGridSource.g:6899:2: ( ruleJvmArgumentTypeReference ) |
| { |
| // InternalGridSource.g:6899:2: ( ruleJvmArgumentTypeReference ) |
| // InternalGridSource.g:6900:3: ruleJvmArgumentTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmArgumentTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1" |
| // InternalGridSource.g:6909:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 : ( ruleJvmArgumentTypeReference ) ; |
| public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6913:1: ( ( ruleJvmArgumentTypeReference ) ) |
| // InternalGridSource.g:6914:2: ( ruleJvmArgumentTypeReference ) |
| { |
| // InternalGridSource.g:6914:2: ( ruleJvmArgumentTypeReference ) |
| // InternalGridSource.g:6915:3: ruleJvmArgumentTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmArgumentTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1" |
| // InternalGridSource.g:6924:1: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 : ( ( ruleValidID ) ) ; |
| public final void rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6928:1: ( ( ( ruleValidID ) ) ) |
| // InternalGridSource.g:6929:2: ( ( ruleValidID ) ) |
| { |
| // InternalGridSource.g:6929:2: ( ( ruleValidID ) ) |
| // InternalGridSource.g:6930:3: ( ruleValidID ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); |
| } |
| // InternalGridSource.g:6931:3: ( ruleValidID ) |
| // InternalGridSource.g:6932:4: ruleValidID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleValidID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1" |
| // InternalGridSource.g:6943:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 : ( ruleJvmArgumentTypeReference ) ; |
| public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6947:1: ( ( ruleJvmArgumentTypeReference ) ) |
| // InternalGridSource.g:6948:2: ( ruleJvmArgumentTypeReference ) |
| { |
| // InternalGridSource.g:6948:2: ( ruleJvmArgumentTypeReference ) |
| // InternalGridSource.g:6949:3: ruleJvmArgumentTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmArgumentTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1" |
| |
| |
| // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1" |
| // InternalGridSource.g:6958:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 : ( ruleJvmArgumentTypeReference ) ; |
| public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6962:1: ( ( ruleJvmArgumentTypeReference ) ) |
| // InternalGridSource.g:6963:2: ( ruleJvmArgumentTypeReference ) |
| { |
| // InternalGridSource.g:6963:2: ( ruleJvmArgumentTypeReference ) |
| // InternalGridSource.g:6964:3: ruleJvmArgumentTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmArgumentTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0" |
| // InternalGridSource.g:6973:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 : ( ruleJvmUpperBound ) ; |
| public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6977:1: ( ( ruleJvmUpperBound ) ) |
| // InternalGridSource.g:6978:2: ( ruleJvmUpperBound ) |
| { |
| // InternalGridSource.g:6978:2: ( ruleJvmUpperBound ) |
| // InternalGridSource.g:6979:3: ruleJvmUpperBound |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmUpperBound(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1" |
| // InternalGridSource.g:6988:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 : ( ruleJvmUpperBoundAnded ) ; |
| public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:6992:1: ( ( ruleJvmUpperBoundAnded ) ) |
| // InternalGridSource.g:6993:2: ( ruleJvmUpperBoundAnded ) |
| { |
| // InternalGridSource.g:6993:2: ( ruleJvmUpperBoundAnded ) |
| // InternalGridSource.g:6994:3: ruleJvmUpperBoundAnded |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmUpperBoundAnded(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0" |
| // InternalGridSource.g:7003:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 : ( ruleJvmLowerBound ) ; |
| public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7007:1: ( ( ruleJvmLowerBound ) ) |
| // InternalGridSource.g:7008:2: ( ruleJvmLowerBound ) |
| { |
| // InternalGridSource.g:7008:2: ( ruleJvmLowerBound ) |
| // InternalGridSource.g:7009:3: ruleJvmLowerBound |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmLowerBound(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0" |
| |
| |
| // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1" |
| // InternalGridSource.g:7018:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 : ( ruleJvmLowerBoundAnded ) ; |
| public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7022:1: ( ( ruleJvmLowerBoundAnded ) ) |
| // InternalGridSource.g:7023:2: ( ruleJvmLowerBoundAnded ) |
| { |
| // InternalGridSource.g:7023:2: ( ruleJvmLowerBoundAnded ) |
| // InternalGridSource.g:7024:3: ruleJvmLowerBoundAnded |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmLowerBoundAnded(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1" |
| |
| |
| // $ANTLR start "rule__JvmUpperBound__TypeReferenceAssignment_1" |
| // InternalGridSource.g:7033:1: rule__JvmUpperBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; |
| public final void rule__JvmUpperBound__TypeReferenceAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7037:1: ( ( ruleJvmTypeReference ) ) |
| // InternalGridSource.g:7038:2: ( ruleJvmTypeReference ) |
| { |
| // InternalGridSource.g:7038:2: ( ruleJvmTypeReference ) |
| // InternalGridSource.g:7039:3: ruleJvmTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmUpperBound__TypeReferenceAssignment_1" |
| |
| |
| // $ANTLR start "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1" |
| // InternalGridSource.g:7048:1: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; |
| public final void rule__JvmUpperBoundAnded__TypeReferenceAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7052:1: ( ( ruleJvmTypeReference ) ) |
| // InternalGridSource.g:7053:2: ( ruleJvmTypeReference ) |
| { |
| // InternalGridSource.g:7053:2: ( ruleJvmTypeReference ) |
| // InternalGridSource.g:7054:3: ruleJvmTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1" |
| |
| |
| // $ANTLR start "rule__JvmLowerBound__TypeReferenceAssignment_1" |
| // InternalGridSource.g:7063:1: rule__JvmLowerBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; |
| public final void rule__JvmLowerBound__TypeReferenceAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7067:1: ( ( ruleJvmTypeReference ) ) |
| // InternalGridSource.g:7068:2: ( ruleJvmTypeReference ) |
| { |
| // InternalGridSource.g:7068:2: ( ruleJvmTypeReference ) |
| // InternalGridSource.g:7069:3: ruleJvmTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmLowerBound__TypeReferenceAssignment_1" |
| |
| |
| // $ANTLR start "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1" |
| // InternalGridSource.g:7078:1: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; |
| public final void rule__JvmLowerBoundAnded__TypeReferenceAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7082:1: ( ( ruleJvmTypeReference ) ) |
| // InternalGridSource.g:7083:2: ( ruleJvmTypeReference ) |
| { |
| // InternalGridSource.g:7083:2: ( ruleJvmTypeReference ) |
| // InternalGridSource.g:7084:3: ruleJvmTypeReference |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleJvmTypeReference(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__StaticAssignment_1_0_0" |
| // InternalGridSource.g:7093:1: rule__XImportDeclaration__StaticAssignment_1_0_0 : ( ( 'static' ) ) ; |
| public final void rule__XImportDeclaration__StaticAssignment_1_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7097:1: ( ( ( 'static' ) ) ) |
| // InternalGridSource.g:7098:2: ( ( 'static' ) ) |
| { |
| // InternalGridSource.g:7098:2: ( ( 'static' ) ) |
| // InternalGridSource.g:7099:3: ( 'static' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); |
| } |
| // InternalGridSource.g:7100:3: ( 'static' ) |
| // InternalGridSource.g:7101:4: 'static' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); |
| } |
| match(input,72,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__StaticAssignment_1_0_0" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__ExtensionAssignment_1_0_1" |
| // InternalGridSource.g:7112:1: rule__XImportDeclaration__ExtensionAssignment_1_0_1 : ( ( 'extension' ) ) ; |
| public final void rule__XImportDeclaration__ExtensionAssignment_1_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7116:1: ( ( ( 'extension' ) ) ) |
| // InternalGridSource.g:7117:2: ( ( 'extension' ) ) |
| { |
| // InternalGridSource.g:7117:2: ( ( 'extension' ) ) |
| // InternalGridSource.g:7118:3: ( 'extension' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); |
| } |
| // InternalGridSource.g:7119:3: ( 'extension' ) |
| // InternalGridSource.g:7120:4: 'extension' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); |
| } |
| match(input,73,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__ExtensionAssignment_1_0_1" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2" |
| // InternalGridSource.g:7131:1: rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 : ( ( ruleQualifiedNameInStaticImport ) ) ; |
| public final void rule__XImportDeclaration__ImportedTypeAssignment_1_0_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7135:1: ( ( ( ruleQualifiedNameInStaticImport ) ) ) |
| // InternalGridSource.g:7136:2: ( ( ruleQualifiedNameInStaticImport ) ) |
| { |
| // InternalGridSource.g:7136:2: ( ( ruleQualifiedNameInStaticImport ) ) |
| // InternalGridSource.g:7137:3: ( ruleQualifiedNameInStaticImport ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); |
| } |
| // InternalGridSource.g:7138:3: ( ruleQualifiedNameInStaticImport ) |
| // InternalGridSource.g:7139:4: ruleQualifiedNameInStaticImport |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleQualifiedNameInStaticImport(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__WildcardAssignment_1_0_3_0" |
| // InternalGridSource.g:7150:1: rule__XImportDeclaration__WildcardAssignment_1_0_3_0 : ( ( '*' ) ) ; |
| public final void rule__XImportDeclaration__WildcardAssignment_1_0_3_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7154:1: ( ( ( '*' ) ) ) |
| // InternalGridSource.g:7155:2: ( ( '*' ) ) |
| { |
| // InternalGridSource.g:7155:2: ( ( '*' ) ) |
| // InternalGridSource.g:7156:3: ( '*' ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); |
| } |
| // InternalGridSource.g:7157:3: ( '*' ) |
| // InternalGridSource.g:7158:4: '*' |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); |
| } |
| match(input,69,FOLLOW_2); if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__WildcardAssignment_1_0_3_0" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1" |
| // InternalGridSource.g:7169:1: rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 : ( ruleValidID ) ; |
| public final void rule__XImportDeclaration__MemberNameAssignment_1_0_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7173:1: ( ( ruleValidID ) ) |
| // InternalGridSource.g:7174:2: ( ruleValidID ) |
| { |
| // InternalGridSource.g:7174:2: ( ruleValidID ) |
| // InternalGridSource.g:7175:3: ruleValidID |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleValidID(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_1_1" |
| // InternalGridSource.g:7184:1: rule__XImportDeclaration__ImportedTypeAssignment_1_1 : ( ( ruleQualifiedName ) ) ; |
| public final void rule__XImportDeclaration__ImportedTypeAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7188:1: ( ( ( ruleQualifiedName ) ) ) |
| // InternalGridSource.g:7189:2: ( ( ruleQualifiedName ) ) |
| { |
| // InternalGridSource.g:7189:2: ( ( ruleQualifiedName ) ) |
| // InternalGridSource.g:7190:3: ( ruleQualifiedName ) |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); |
| } |
| // InternalGridSource.g:7191:3: ( ruleQualifiedName ) |
| // InternalGridSource.g:7192:4: ruleQualifiedName |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleQualifiedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); |
| } |
| |
| } |
| |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2" |
| // InternalGridSource.g:7203:1: rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 : ( ruleQualifiedNameWithWildcard ) ; |
| public final void rule__XImportDeclaration__ImportedNamespaceAssignment_1_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalGridSource.g:7207:1: ( ( ruleQualifiedNameWithWildcard ) ) |
| // InternalGridSource.g:7208:2: ( ruleQualifiedNameWithWildcard ) |
| { |
| // InternalGridSource.g:7208:2: ( ruleQualifiedNameWithWildcard ) |
| // InternalGridSource.g:7209:3: ruleQualifiedNameWithWildcard |
| { |
| if ( state.backtracking==0 ) { |
| before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); |
| } |
| pushFollow(FOLLOW_2); |
| ruleQualifiedNameWithWildcard(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| if ( state.backtracking==0 ) { |
| after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); |
| } |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2" |
| |
| // Delegated rules |
| |
| |
| protected DFA8 dfa8 = new DFA8(this); |
| static final String dfa_1s = "\7\uffff"; |
| static final String dfa_2s = "\2\uffff\1\4\3\uffff\1\4"; |
| static final String dfa_3s = "\1\4\1\uffff\1\42\1\4\2\uffff\1\42"; |
| static final String dfa_4s = "\1\110\1\uffff\1\107\1\105\2\uffff\1\107"; |
| static final String dfa_5s = "\1\uffff\1\1\2\uffff\1\2\1\3\1\uffff"; |
| static final String dfa_6s = "\7\uffff}>"; |
| static final String[] dfa_7s = { |
| "\1\2\103\uffff\1\1", |
| "", |
| "\1\3\44\uffff\1\4", |
| "\1\6\100\uffff\1\5", |
| "", |
| "", |
| "\1\3\44\uffff\1\4" |
| }; |
| |
| static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); |
| static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s); |
| static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); |
| static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s); |
| static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); |
| static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s); |
| static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s); |
| |
| class DFA8 extends DFA { |
| |
| public DFA8(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 8; |
| this.eot = dfa_1; |
| this.eof = dfa_2; |
| this.min = dfa_3; |
| this.max = dfa_4; |
| this.accept = dfa_5; |
| this.special = dfa_6; |
| this.transition = dfa_7; |
| } |
| public String getDescription() { |
| return "1206:1: rule__XImportDeclaration__Alternatives_1 : ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) );"; |
| } |
| } |
| |
| |
| 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[]{0x0000000000000012L}); |
| public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000400000L}); |
| public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x2004000000000010L}); |
| public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000800000L}); |
| public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000001000000L}); |
| public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000006000000L}); |
| public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000004000002L}); |
| public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000102000000L}); |
| public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000100000002L}); |
| public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000008000000L}); |
| public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000020000000L}); |
| public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000010000000L}); |
| public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000010000002L}); |
| public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000040000000L}); |
| public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000080000000L}); |
| public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000200000000L}); |
| public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x00D096E800000000L}); |
| public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000400000000L}); |
| public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000800000000L}); |
| public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000001000000000L}); |
| public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000000040L}); |
| public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000002000000000L}); |
| public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000004000000000L}); |
| public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000008000000000L}); |
| public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000010000000000L}); |
| public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000020000000000L}); |
| public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000040000000000L}); |
| public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000080000000000L}); |
| public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000006020L}); |
| public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000200000000000L}); |
| public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000400000000000L}); |
| public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000800000000000L}); |
| public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0001000000000040L}); |
| public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0006000000000000L}); |
| public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0008000000000000L}); |
| public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0010000000000000L}); |
| public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0024000000000000L}); |
| public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0040000000000000L}); |
| public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0080000000000000L}); |
| public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000001000800000L}); |
| public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0500000002000000L}); |
| public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0500000000000002L}); |
| public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000400000002L}); |
| public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x00000000001F8000L}); |
| public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0200000000000000L}); |
| public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000080L}); |
| public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000020L}); |
| public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0800000000000000L}); |
| public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0800000000000002L}); |
| public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x1000000000000000L}); |
| public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x200C000000000010L}); |
| public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x4000000000000000L}); |
| public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x4000000000000002L}); |
| public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x8000000000000000L}); |
| public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x2004000000000010L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x4000000000000000L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000014L}); |
| public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); |
| public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000008L}); |
| public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L}); |
| public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000100L}); |
| public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L}); |
| public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000200L}); |
| public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000020L}); |
| |
| } |
