mirror of https://github.com/Minres/RDL-Editor.git
27661 lines
870 KiB
Java
27661 lines
870 KiB
Java
package com.minres.rdl.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 com.minres.rdl.services.RDLGrammarAccess;
|
|
|
|
|
|
|
|
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 InternalRDLParser extends AbstractInternalContentAssistParser {
|
|
public static final String[] tokenNames = new String[] {
|
|
"<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_STR", "RULE_ID", "RULE_NUM", "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_ESCAPE_JSP", "RULE_ESCAPE_ORDL", "'string'", "'number'", "'boolean'", "'addrmap'", "'reg'", "'regfile'", "'field'", "'ref'", "'signal'", "'all'", "'name'", "'desc'", "'arbiter'", "'rset'", "'rclr'", "'woclr'", "'woset'", "'we'", "'wel'", "'swwe'", "'swwel'", "'hwset'", "'hwclr'", "'swmod'", "'swacc'", "'sticky'", "'stickybit'", "'intr'", "'anded'", "'ored'", "'xored'", "'counter'", "'overflow'", "'sharedextbus'", "'errextbus'", "'reset'", "'littleendian'", "'bigendian'", "'rsvdset'", "'rsvdsetX'", "'bridge'", "'shared'", "'msb0'", "'lsb0'", "'sync'", "'async'", "'cpuif_reset'", "'field_reset'", "'activehigh'", "'activelow'", "'singlepulse'", "'underflow'", "'incr'", "'decr'", "'incrwidth'", "'decrwidth'", "'incrvalue'", "'decrvalue'", "'saturate'", "'decrsaturate'", "'threshold'", "'decrthreshold'", "'dontcompare'", "'donttest'", "'internal'", "'alignment'", "'regwidth'", "'fieldwidth'", "'signalwidth'", "'accesswidth'", "'sw'", "'hw'", "'addressing'", "'precedence'", "'encode'", "'resetsignal'", "'clock'", "'mask'", "'enable'", "'hwenable'", "'hwmask'", "'haltmask'", "'haltenable'", "'halt'", "'next'", "'UNDEFINED'", "'true'", "'false'", "'rw'", "'wr'", "'r'", "'w'", "'na'", "'compact'", "'regalign'", "'fullalign'", "'posedge'", "'negedge'", "'bothedge'", "'level'", "'nonsticky'", "';'", "'`include'", "'property'", "'{'", "'}'", "'type'", "'='", "'default'", "'component'", "'|'", "'alias'", "','", "'@'", "'+='", "'%='", "'['", "']'", "':'", "'->'", "'.'", "'enum'", "'external'"
|
|
};
|
|
public static final int T__50=50;
|
|
public static final int T__59=59;
|
|
public static final int T__55=55;
|
|
public static final int T__56=56;
|
|
public static final int T__57=57;
|
|
public static final int T__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__133=133;
|
|
public static final int T__132=132;
|
|
public static final int T__60=60;
|
|
public static final int T__61=61;
|
|
public static final int T__134=134;
|
|
public static final int RULE_ID=5;
|
|
public static final int T__131=131;
|
|
public static final int T__130=130;
|
|
public static final int T__66=66;
|
|
public static final int RULE_ML_COMMENT=8;
|
|
public static final int T__67=67;
|
|
public static final int T__129=129;
|
|
public static final int T__68=68;
|
|
public static final int T__69=69;
|
|
public static final int T__62=62;
|
|
public static final int T__126=126;
|
|
public static final int T__63=63;
|
|
public static final int T__125=125;
|
|
public static final int T__64=64;
|
|
public static final int T__128=128;
|
|
public static final int T__65=65;
|
|
public static final int T__127=127;
|
|
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__30=30;
|
|
public static final int T__31=31;
|
|
public static final int T__32=32;
|
|
public static final int T__48=48;
|
|
public static final int T__49=49;
|
|
public static final int RULE_STR=4;
|
|
public static final int T__44=44;
|
|
public static final int T__45=45;
|
|
public static final int T__46=46;
|
|
public static final int T__47=47;
|
|
public static final int T__40=40;
|
|
public static final int T__41=41;
|
|
public static final int T__42=42;
|
|
public static final int T__43=43;
|
|
public static final int T__91=91;
|
|
public static final int T__100=100;
|
|
public static final int T__92=92;
|
|
public static final int T__93=93;
|
|
public static final int T__102=102;
|
|
public static final int T__94=94;
|
|
public static final int T__101=101;
|
|
public static final int T__90=90;
|
|
public static final int T__19=19;
|
|
public static final int T__15=15;
|
|
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__99=99;
|
|
public static final int RULE_NUM=6;
|
|
public static final int T__12=12;
|
|
public static final int T__13=13;
|
|
public static final int T__14=14;
|
|
public static final int T__95=95;
|
|
public static final int T__96=96;
|
|
public static final int T__97=97;
|
|
public static final int T__98=98;
|
|
public static final int RULE_ESCAPE_ORDL=11;
|
|
public static final int T__26=26;
|
|
public static final int T__27=27;
|
|
public static final int T__28=28;
|
|
public static final int T__29=29;
|
|
public static final int T__22=22;
|
|
public static final int T__23=23;
|
|
public static final int T__24=24;
|
|
public static final int T__25=25;
|
|
public static final int T__20=20;
|
|
public static final int T__21=21;
|
|
public static final int T__122=122;
|
|
public static final int T__70=70;
|
|
public static final int T__121=121;
|
|
public static final int T__71=71;
|
|
public static final int T__124=124;
|
|
public static final int T__72=72;
|
|
public static final int T__123=123;
|
|
public static final int T__120=120;
|
|
public static final int RULE_SL_COMMENT=9;
|
|
public static final int T__77=77;
|
|
public static final int T__119=119;
|
|
public static final int T__78=78;
|
|
public static final int T__118=118;
|
|
public static final int T__79=79;
|
|
public static final int T__73=73;
|
|
public static final int T__115=115;
|
|
public static final int EOF=-1;
|
|
public static final int T__74=74;
|
|
public static final int T__114=114;
|
|
public static final int T__75=75;
|
|
public static final int T__117=117;
|
|
public static final int T__76=76;
|
|
public static final int T__116=116;
|
|
public static final int T__80=80;
|
|
public static final int T__111=111;
|
|
public static final int T__81=81;
|
|
public static final int T__110=110;
|
|
public static final int RULE_ESCAPE_JSP=10;
|
|
public static final int T__82=82;
|
|
public static final int T__113=113;
|
|
public static final int T__83=83;
|
|
public static final int T__112=112;
|
|
public static final int RULE_WS=7;
|
|
public static final int T__88=88;
|
|
public static final int T__108=108;
|
|
public static final int T__89=89;
|
|
public static final int T__107=107;
|
|
public static final int T__109=109;
|
|
public static final int T__84=84;
|
|
public static final int T__104=104;
|
|
public static final int T__85=85;
|
|
public static final int T__103=103;
|
|
public static final int T__86=86;
|
|
public static final int T__106=106;
|
|
public static final int T__87=87;
|
|
public static final int T__105=105;
|
|
|
|
// delegates
|
|
// delegators
|
|
|
|
|
|
public InternalRDLParser(TokenStream input) {
|
|
this(input, new RecognizerSharedState());
|
|
}
|
|
public InternalRDLParser(TokenStream input, RecognizerSharedState state) {
|
|
super(input, state);
|
|
|
|
}
|
|
|
|
|
|
public String[] getTokenNames() { return InternalRDLParser.tokenNames; }
|
|
public String getGrammarFileName() { return "InternalRDL.g"; }
|
|
|
|
|
|
private RDLGrammarAccess grammarAccess;
|
|
|
|
public void setGrammarAccess(RDLGrammarAccess grammarAccess) {
|
|
this.grammarAccess = grammarAccess;
|
|
}
|
|
|
|
@Override
|
|
protected Grammar getGrammar() {
|
|
return grammarAccess.getGrammar();
|
|
}
|
|
|
|
@Override
|
|
protected String getValueForTokenName(String tokenName) {
|
|
return tokenName;
|
|
}
|
|
|
|
|
|
|
|
// $ANTLR start "entryRuleRoot"
|
|
// InternalRDL.g:54:1: entryRuleRoot : ruleRoot EOF ;
|
|
public final void entryRuleRoot() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:55:1: ( ruleRoot EOF )
|
|
// InternalRDL.g:56:1: ruleRoot EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleRoot();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleRoot"
|
|
|
|
|
|
// $ANTLR start "ruleRoot"
|
|
// InternalRDL.g:63:1: ruleRoot : ( ( rule__Root__Alternatives )* ) ;
|
|
public final void ruleRoot() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:67:2: ( ( ( rule__Root__Alternatives )* ) )
|
|
// InternalRDL.g:68:2: ( ( rule__Root__Alternatives )* )
|
|
{
|
|
// InternalRDL.g:68:2: ( ( rule__Root__Alternatives )* )
|
|
// InternalRDL.g:69:3: ( rule__Root__Alternatives )*
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:70:3: ( rule__Root__Alternatives )*
|
|
loop1:
|
|
do {
|
|
int alt1=2;
|
|
int LA1_0 = input.LA(1);
|
|
|
|
if ( (LA1_0==RULE_ID||(LA1_0>=15 && LA1_0<=18)||LA1_0==20||(LA1_0>=22 && LA1_0<=97)||(LA1_0>=108 && LA1_0<=112)||(LA1_0>=114 && LA1_0<=115)||LA1_0==120||LA1_0==123||(LA1_0>=133 && LA1_0<=134)) ) {
|
|
alt1=1;
|
|
}
|
|
|
|
|
|
switch (alt1) {
|
|
case 1 :
|
|
// InternalRDL.g:70:4: rule__Root__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_3);
|
|
rule__Root__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop1;
|
|
}
|
|
} while (true);
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleRoot"
|
|
|
|
|
|
// $ANTLR start "entryRuleInclude"
|
|
// InternalRDL.g:79:1: entryRuleInclude : ruleInclude EOF ;
|
|
public final void entryRuleInclude() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:80:1: ( ruleInclude EOF )
|
|
// InternalRDL.g:81:1: ruleInclude EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getIncludeRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleInclude();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getIncludeRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleInclude"
|
|
|
|
|
|
// $ANTLR start "ruleInclude"
|
|
// InternalRDL.g:88:1: ruleInclude : ( ( rule__Include__Group__0 ) ) ;
|
|
public final void ruleInclude() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:92:2: ( ( ( rule__Include__Group__0 ) ) )
|
|
// InternalRDL.g:93:2: ( ( rule__Include__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:93:2: ( ( rule__Include__Group__0 ) )
|
|
// InternalRDL.g:94:3: ( rule__Include__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getIncludeAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:95:3: ( rule__Include__Group__0 )
|
|
// InternalRDL.g:95:4: rule__Include__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Include__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getIncludeAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleInclude"
|
|
|
|
|
|
// $ANTLR start "entryRulePropertyDefinition"
|
|
// InternalRDL.g:104:1: entryRulePropertyDefinition : rulePropertyDefinition EOF ;
|
|
public final void entryRulePropertyDefinition() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:105:1: ( rulePropertyDefinition EOF )
|
|
// InternalRDL.g:106:1: rulePropertyDefinition EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
rulePropertyDefinition();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRulePropertyDefinition"
|
|
|
|
|
|
// $ANTLR start "rulePropertyDefinition"
|
|
// InternalRDL.g:113:1: rulePropertyDefinition : ( ( rule__PropertyDefinition__Group__0 ) ) ;
|
|
public final void rulePropertyDefinition() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:117:2: ( ( ( rule__PropertyDefinition__Group__0 ) ) )
|
|
// InternalRDL.g:118:2: ( ( rule__PropertyDefinition__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:118:2: ( ( rule__PropertyDefinition__Group__0 ) )
|
|
// InternalRDL.g:119:3: ( rule__PropertyDefinition__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:120:3: ( rule__PropertyDefinition__Group__0 )
|
|
// InternalRDL.g:120:4: rule__PropertyDefinition__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rulePropertyDefinition"
|
|
|
|
|
|
// $ANTLR start "entryRulePropertyDefault"
|
|
// InternalRDL.g:129:1: entryRulePropertyDefault : rulePropertyDefault EOF ;
|
|
public final void entryRulePropertyDefault() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:130:1: ( rulePropertyDefault EOF )
|
|
// InternalRDL.g:131:1: rulePropertyDefault EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
rulePropertyDefault();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRulePropertyDefault"
|
|
|
|
|
|
// $ANTLR start "rulePropertyDefault"
|
|
// InternalRDL.g:138:1: rulePropertyDefault : ( ( rule__PropertyDefault__Group__0 ) ) ;
|
|
public final void rulePropertyDefault() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:142:2: ( ( ( rule__PropertyDefault__Group__0 ) ) )
|
|
// InternalRDL.g:143:2: ( ( rule__PropertyDefault__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:143:2: ( ( rule__PropertyDefault__Group__0 ) )
|
|
// InternalRDL.g:144:3: ( rule__PropertyDefault__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:145:3: ( rule__PropertyDefault__Group__0 )
|
|
// InternalRDL.g:145:4: rule__PropertyDefault__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefault__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rulePropertyDefault"
|
|
|
|
|
|
// $ANTLR start "entryRulePropertyUsage"
|
|
// InternalRDL.g:154:1: entryRulePropertyUsage : rulePropertyUsage EOF ;
|
|
public final void entryRulePropertyUsage() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:155:1: ( rulePropertyUsage EOF )
|
|
// InternalRDL.g:156:1: rulePropertyUsage EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyUsageRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
rulePropertyUsage();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyUsageRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRulePropertyUsage"
|
|
|
|
|
|
// $ANTLR start "rulePropertyUsage"
|
|
// InternalRDL.g:163:1: rulePropertyUsage : ( ( rule__PropertyUsage__Group__0 ) ) ;
|
|
public final void rulePropertyUsage() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:167:2: ( ( ( rule__PropertyUsage__Group__0 ) ) )
|
|
// InternalRDL.g:168:2: ( ( rule__PropertyUsage__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:168:2: ( ( rule__PropertyUsage__Group__0 ) )
|
|
// InternalRDL.g:169:3: ( rule__PropertyUsage__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyUsageAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:170:3: ( rule__PropertyUsage__Group__0 )
|
|
// InternalRDL.g:170:4: rule__PropertyUsage__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyUsage__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyUsageAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rulePropertyUsage"
|
|
|
|
|
|
// $ANTLR start "entryRuleComponentDefinition"
|
|
// InternalRDL.g:179:1: entryRuleComponentDefinition : ruleComponentDefinition EOF ;
|
|
public final void entryRuleComponentDefinition() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:180:1: ( ruleComponentDefinition EOF )
|
|
// InternalRDL.g:181:1: ruleComponentDefinition EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleComponentDefinition();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleComponentDefinition"
|
|
|
|
|
|
// $ANTLR start "ruleComponentDefinition"
|
|
// InternalRDL.g:188:1: ruleComponentDefinition : ( ( rule__ComponentDefinition__Group__0 ) ) ;
|
|
public final void ruleComponentDefinition() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:192:2: ( ( ( rule__ComponentDefinition__Group__0 ) ) )
|
|
// InternalRDL.g:193:2: ( ( rule__ComponentDefinition__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:193:2: ( ( rule__ComponentDefinition__Group__0 ) )
|
|
// InternalRDL.g:194:3: ( rule__ComponentDefinition__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:195:3: ( rule__ComponentDefinition__Group__0 )
|
|
// InternalRDL.g:195:4: rule__ComponentDefinition__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleComponentDefinition"
|
|
|
|
|
|
// $ANTLR start "entryRuleInstantiation"
|
|
// InternalRDL.g:204:1: entryRuleInstantiation : ruleInstantiation EOF ;
|
|
public final void entryRuleInstantiation() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:205:1: ( ruleInstantiation EOF )
|
|
// InternalRDL.g:206:1: ruleInstantiation EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleInstantiation();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleInstantiation"
|
|
|
|
|
|
// $ANTLR start "ruleInstantiation"
|
|
// InternalRDL.g:213:1: ruleInstantiation : ( ( rule__Instantiation__Group__0 ) ) ;
|
|
public final void ruleInstantiation() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:217:2: ( ( ( rule__Instantiation__Group__0 ) ) )
|
|
// InternalRDL.g:218:2: ( ( rule__Instantiation__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:218:2: ( ( rule__Instantiation__Group__0 ) )
|
|
// InternalRDL.g:219:3: ( rule__Instantiation__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:220:3: ( rule__Instantiation__Group__0 )
|
|
// InternalRDL.g:220:4: rule__Instantiation__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleInstantiation"
|
|
|
|
|
|
// $ANTLR start "entryRuleComponentInstance"
|
|
// InternalRDL.g:229:1: entryRuleComponentInstance : ruleComponentInstance EOF ;
|
|
public final void entryRuleComponentInstance() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:230:1: ( ruleComponentInstance EOF )
|
|
// InternalRDL.g:231:1: ruleComponentInstance EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleComponentInstance();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleComponentInstance"
|
|
|
|
|
|
// $ANTLR start "ruleComponentInstance"
|
|
// InternalRDL.g:238:1: ruleComponentInstance : ( ( rule__ComponentInstance__Group__0 ) ) ;
|
|
public final void ruleComponentInstance() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:242:2: ( ( ( rule__ComponentInstance__Group__0 ) ) )
|
|
// InternalRDL.g:243:2: ( ( rule__ComponentInstance__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:243:2: ( ( rule__ComponentInstance__Group__0 ) )
|
|
// InternalRDL.g:244:3: ( rule__ComponentInstance__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:245:3: ( rule__ComponentInstance__Group__0 )
|
|
// InternalRDL.g:245:4: rule__ComponentInstance__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleComponentInstance"
|
|
|
|
|
|
// $ANTLR start "entryRuleRange"
|
|
// InternalRDL.g:254:1: entryRuleRange : ruleRange EOF ;
|
|
public final void entryRuleRange() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:255:1: ( ruleRange EOF )
|
|
// InternalRDL.g:256:1: ruleRange EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleRange();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleRange"
|
|
|
|
|
|
// $ANTLR start "ruleRange"
|
|
// InternalRDL.g:263:1: ruleRange : ( ( rule__Range__Group__0 ) ) ;
|
|
public final void ruleRange() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:267:2: ( ( ( rule__Range__Group__0 ) ) )
|
|
// InternalRDL.g:268:2: ( ( rule__Range__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:268:2: ( ( rule__Range__Group__0 ) )
|
|
// InternalRDL.g:269:3: ( rule__Range__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:270:3: ( rule__Range__Group__0 )
|
|
// InternalRDL.g:270:4: rule__Range__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleRange"
|
|
|
|
|
|
// $ANTLR start "entryRulePropertyAssignment"
|
|
// InternalRDL.g:279:1: entryRulePropertyAssignment : rulePropertyAssignment EOF ;
|
|
public final void entryRulePropertyAssignment() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:280:1: ( rulePropertyAssignment EOF )
|
|
// InternalRDL.g:281:1: rulePropertyAssignment EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
rulePropertyAssignment();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRulePropertyAssignment"
|
|
|
|
|
|
// $ANTLR start "rulePropertyAssignment"
|
|
// InternalRDL.g:288:1: rulePropertyAssignment : ( ( rule__PropertyAssignment__Alternatives ) ) ;
|
|
public final void rulePropertyAssignment() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:292:2: ( ( ( rule__PropertyAssignment__Alternatives ) ) )
|
|
// InternalRDL.g:293:2: ( ( rule__PropertyAssignment__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:293:2: ( ( rule__PropertyAssignment__Alternatives ) )
|
|
// InternalRDL.g:294:3: ( rule__PropertyAssignment__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:295:3: ( rule__PropertyAssignment__Alternatives )
|
|
// InternalRDL.g:295:4: rule__PropertyAssignment__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyAssignment__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rulePropertyAssignment"
|
|
|
|
|
|
// $ANTLR start "entryRuleDefaultProperyAssignment"
|
|
// InternalRDL.g:304:1: entryRuleDefaultProperyAssignment : ruleDefaultProperyAssignment EOF ;
|
|
public final void entryRuleDefaultProperyAssignment() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:305:1: ( ruleDefaultProperyAssignment EOF )
|
|
// InternalRDL.g:306:1: ruleDefaultProperyAssignment EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getDefaultProperyAssignmentRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleDefaultProperyAssignment();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getDefaultProperyAssignmentRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleDefaultProperyAssignment"
|
|
|
|
|
|
// $ANTLR start "ruleDefaultProperyAssignment"
|
|
// InternalRDL.g:313:1: ruleDefaultProperyAssignment : ( ( rule__DefaultProperyAssignment__Group__0 ) ) ;
|
|
public final void ruleDefaultProperyAssignment() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:317:2: ( ( ( rule__DefaultProperyAssignment__Group__0 ) ) )
|
|
// InternalRDL.g:318:2: ( ( rule__DefaultProperyAssignment__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:318:2: ( ( rule__DefaultProperyAssignment__Group__0 ) )
|
|
// InternalRDL.g:319:3: ( rule__DefaultProperyAssignment__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getDefaultProperyAssignmentAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:320:3: ( rule__DefaultProperyAssignment__Group__0 )
|
|
// InternalRDL.g:320:4: rule__DefaultProperyAssignment__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__DefaultProperyAssignment__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getDefaultProperyAssignmentAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleDefaultProperyAssignment"
|
|
|
|
|
|
// $ANTLR start "entryRuleExplicitPropertyAssignment"
|
|
// InternalRDL.g:329:1: entryRuleExplicitPropertyAssignment : ruleExplicitPropertyAssignment EOF ;
|
|
public final void entryRuleExplicitPropertyAssignment() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:330:1: ( ruleExplicitPropertyAssignment EOF )
|
|
// InternalRDL.g:331:1: ruleExplicitPropertyAssignment EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleExplicitPropertyAssignment();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleExplicitPropertyAssignment"
|
|
|
|
|
|
// $ANTLR start "ruleExplicitPropertyAssignment"
|
|
// InternalRDL.g:338:1: ruleExplicitPropertyAssignment : ( ( rule__ExplicitPropertyAssignment__Alternatives ) ) ;
|
|
public final void ruleExplicitPropertyAssignment() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:342:2: ( ( ( rule__ExplicitPropertyAssignment__Alternatives ) ) )
|
|
// InternalRDL.g:343:2: ( ( rule__ExplicitPropertyAssignment__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:343:2: ( ( rule__ExplicitPropertyAssignment__Alternatives ) )
|
|
// InternalRDL.g:344:3: ( rule__ExplicitPropertyAssignment__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:345:3: ( rule__ExplicitPropertyAssignment__Alternatives )
|
|
// InternalRDL.g:345:4: rule__ExplicitPropertyAssignment__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleExplicitPropertyAssignment"
|
|
|
|
|
|
// $ANTLR start "entryRulePostPropertyAssignment"
|
|
// InternalRDL.g:354:1: entryRulePostPropertyAssignment : rulePostPropertyAssignment EOF ;
|
|
public final void entryRulePostPropertyAssignment() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:355:1: ( rulePostPropertyAssignment EOF )
|
|
// InternalRDL.g:356:1: rulePostPropertyAssignment EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
rulePostPropertyAssignment();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRulePostPropertyAssignment"
|
|
|
|
|
|
// $ANTLR start "rulePostPropertyAssignment"
|
|
// InternalRDL.g:363:1: rulePostPropertyAssignment : ( ( rule__PostPropertyAssignment__Group__0 ) ) ;
|
|
public final void rulePostPropertyAssignment() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:367:2: ( ( ( rule__PostPropertyAssignment__Group__0 ) ) )
|
|
// InternalRDL.g:368:2: ( ( rule__PostPropertyAssignment__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:368:2: ( ( rule__PostPropertyAssignment__Group__0 ) )
|
|
// InternalRDL.g:369:3: ( rule__PostPropertyAssignment__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:370:3: ( rule__PostPropertyAssignment__Group__0 )
|
|
// InternalRDL.g:370:4: rule__PostPropertyAssignment__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rulePostPropertyAssignment"
|
|
|
|
|
|
// $ANTLR start "entryRuleInstancePropertyRef"
|
|
// InternalRDL.g:379:1: entryRuleInstancePropertyRef : ruleInstancePropertyRef EOF ;
|
|
public final void entryRuleInstancePropertyRef() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:380:1: ( ruleInstancePropertyRef EOF )
|
|
// InternalRDL.g:381:1: ruleInstancePropertyRef EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleInstancePropertyRef();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleInstancePropertyRef"
|
|
|
|
|
|
// $ANTLR start "ruleInstancePropertyRef"
|
|
// InternalRDL.g:388:1: ruleInstancePropertyRef : ( ( rule__InstancePropertyRef__Group__0 ) ) ;
|
|
public final void ruleInstancePropertyRef() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:392:2: ( ( ( rule__InstancePropertyRef__Group__0 ) ) )
|
|
// InternalRDL.g:393:2: ( ( rule__InstancePropertyRef__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:393:2: ( ( rule__InstancePropertyRef__Group__0 ) )
|
|
// InternalRDL.g:394:3: ( rule__InstancePropertyRef__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:395:3: ( rule__InstancePropertyRef__Group__0 )
|
|
// InternalRDL.g:395:4: rule__InstancePropertyRef__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstancePropertyRef__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleInstancePropertyRef"
|
|
|
|
|
|
// $ANTLR start "entryRuleInstanceRef"
|
|
// InternalRDL.g:404:1: entryRuleInstanceRef : ruleInstanceRef EOF ;
|
|
public final void entryRuleInstanceRef() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:405:1: ( ruleInstanceRef EOF )
|
|
// InternalRDL.g:406:1: ruleInstanceRef EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstanceRefRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleInstanceRef();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstanceRefRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleInstanceRef"
|
|
|
|
|
|
// $ANTLR start "ruleInstanceRef"
|
|
// InternalRDL.g:413:1: ruleInstanceRef : ( ( rule__InstanceRef__Group__0 ) ) ;
|
|
public final void ruleInstanceRef() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:417:2: ( ( ( rule__InstanceRef__Group__0 ) ) )
|
|
// InternalRDL.g:418:2: ( ( rule__InstanceRef__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:418:2: ( ( rule__InstanceRef__Group__0 ) )
|
|
// InternalRDL.g:419:3: ( rule__InstanceRef__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstanceRefAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:420:3: ( rule__InstanceRef__Group__0 )
|
|
// InternalRDL.g:420:4: rule__InstanceRef__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstanceRef__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstanceRefAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleInstanceRef"
|
|
|
|
|
|
// $ANTLR start "entryRuleHierInstanceRef"
|
|
// InternalRDL.g:429:1: entryRuleHierInstanceRef : ruleHierInstanceRef EOF ;
|
|
public final void entryRuleHierInstanceRef() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:430:1: ( ruleHierInstanceRef EOF )
|
|
// InternalRDL.g:431:1: ruleHierInstanceRef EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getHierInstanceRefRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleHierInstanceRef();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getHierInstanceRefRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleHierInstanceRef"
|
|
|
|
|
|
// $ANTLR start "ruleHierInstanceRef"
|
|
// InternalRDL.g:438:1: ruleHierInstanceRef : ( ( rule__HierInstanceRef__Group__0 ) ) ;
|
|
public final void ruleHierInstanceRef() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:442:2: ( ( ( rule__HierInstanceRef__Group__0 ) ) )
|
|
// InternalRDL.g:443:2: ( ( rule__HierInstanceRef__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:443:2: ( ( rule__HierInstanceRef__Group__0 ) )
|
|
// InternalRDL.g:444:3: ( rule__HierInstanceRef__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getHierInstanceRefAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:445:3: ( rule__HierInstanceRef__Group__0 )
|
|
// InternalRDL.g:445:4: rule__HierInstanceRef__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__HierInstanceRef__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getHierInstanceRefAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleHierInstanceRef"
|
|
|
|
|
|
// $ANTLR start "entryRulePropertyAssignmentRhs"
|
|
// InternalRDL.g:454:1: entryRulePropertyAssignmentRhs : rulePropertyAssignmentRhs EOF ;
|
|
public final void entryRulePropertyAssignmentRhs() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:455:1: ( rulePropertyAssignmentRhs EOF )
|
|
// InternalRDL.g:456:1: rulePropertyAssignmentRhs EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
rulePropertyAssignmentRhs();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRulePropertyAssignmentRhs"
|
|
|
|
|
|
// $ANTLR start "rulePropertyAssignmentRhs"
|
|
// InternalRDL.g:463:1: rulePropertyAssignmentRhs : ( ( rule__PropertyAssignmentRhs__Alternatives ) ) ;
|
|
public final void rulePropertyAssignmentRhs() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:467:2: ( ( ( rule__PropertyAssignmentRhs__Alternatives ) ) )
|
|
// InternalRDL.g:468:2: ( ( rule__PropertyAssignmentRhs__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:468:2: ( ( rule__PropertyAssignmentRhs__Alternatives ) )
|
|
// InternalRDL.g:469:3: ( rule__PropertyAssignmentRhs__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:470:3: ( rule__PropertyAssignmentRhs__Alternatives )
|
|
// InternalRDL.g:470:4: rule__PropertyAssignmentRhs__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyAssignmentRhs__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rulePropertyAssignmentRhs"
|
|
|
|
|
|
// $ANTLR start "entryRuleConcat"
|
|
// InternalRDL.g:479:1: entryRuleConcat : ruleConcat EOF ;
|
|
public final void entryRuleConcat() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:480:1: ( ruleConcat EOF )
|
|
// InternalRDL.g:481:1: ruleConcat EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleConcat();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleConcat"
|
|
|
|
|
|
// $ANTLR start "ruleConcat"
|
|
// InternalRDL.g:488:1: ruleConcat : ( ( rule__Concat__Group__0 ) ) ;
|
|
public final void ruleConcat() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:492:2: ( ( ( rule__Concat__Group__0 ) ) )
|
|
// InternalRDL.g:493:2: ( ( rule__Concat__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:493:2: ( ( rule__Concat__Group__0 ) )
|
|
// InternalRDL.g:494:3: ( rule__Concat__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:495:3: ( rule__Concat__Group__0 )
|
|
// InternalRDL.g:495:4: rule__Concat__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Concat__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleConcat"
|
|
|
|
|
|
// $ANTLR start "entryRuleConcatElem"
|
|
// InternalRDL.g:504:1: entryRuleConcatElem : ruleConcatElem EOF ;
|
|
public final void entryRuleConcatElem() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:505:1: ( ruleConcatElem EOF )
|
|
// InternalRDL.g:506:1: ruleConcatElem EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatElemRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleConcatElem();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatElemRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleConcatElem"
|
|
|
|
|
|
// $ANTLR start "ruleConcatElem"
|
|
// InternalRDL.g:513:1: ruleConcatElem : ( ( rule__ConcatElem__Alternatives ) ) ;
|
|
public final void ruleConcatElem() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:517:2: ( ( ( rule__ConcatElem__Alternatives ) ) )
|
|
// InternalRDL.g:518:2: ( ( rule__ConcatElem__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:518:2: ( ( rule__ConcatElem__Alternatives ) )
|
|
// InternalRDL.g:519:3: ( rule__ConcatElem__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatElemAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:520:3: ( rule__ConcatElem__Alternatives )
|
|
// InternalRDL.g:520:4: rule__ConcatElem__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ConcatElem__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatElemAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleConcatElem"
|
|
|
|
|
|
// $ANTLR start "entryRulePropertyRvalueConstant"
|
|
// InternalRDL.g:529:1: entryRulePropertyRvalueConstant : rulePropertyRvalueConstant EOF ;
|
|
public final void entryRulePropertyRvalueConstant() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:530:1: ( rulePropertyRvalueConstant EOF )
|
|
// InternalRDL.g:531:1: rulePropertyRvalueConstant EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyRvalueConstantRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
rulePropertyRvalueConstant();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyRvalueConstantRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRulePropertyRvalueConstant"
|
|
|
|
|
|
// $ANTLR start "rulePropertyRvalueConstant"
|
|
// InternalRDL.g:538:1: rulePropertyRvalueConstant : ( ( rule__PropertyRvalueConstant__Alternatives ) ) ;
|
|
public final void rulePropertyRvalueConstant() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:542:2: ( ( ( rule__PropertyRvalueConstant__Alternatives ) ) )
|
|
// InternalRDL.g:543:2: ( ( rule__PropertyRvalueConstant__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:543:2: ( ( rule__PropertyRvalueConstant__Alternatives ) )
|
|
// InternalRDL.g:544:3: ( rule__PropertyRvalueConstant__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyRvalueConstantAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:545:3: ( rule__PropertyRvalueConstant__Alternatives )
|
|
// InternalRDL.g:545:4: rule__PropertyRvalueConstant__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyRvalueConstant__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyRvalueConstantAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rulePropertyRvalueConstant"
|
|
|
|
|
|
// $ANTLR start "entryRuleEnumDefinition"
|
|
// InternalRDL.g:554:1: entryRuleEnumDefinition : ruleEnumDefinition EOF ;
|
|
public final void entryRuleEnumDefinition() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:555:1: ( ruleEnumDefinition EOF )
|
|
// InternalRDL.g:556:1: ruleEnumDefinition EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumDefinitionRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleEnumDefinition();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumDefinitionRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleEnumDefinition"
|
|
|
|
|
|
// $ANTLR start "ruleEnumDefinition"
|
|
// InternalRDL.g:563:1: ruleEnumDefinition : ( ( rule__EnumDefinition__Group__0 ) ) ;
|
|
public final void ruleEnumDefinition() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:567:2: ( ( ( rule__EnumDefinition__Group__0 ) ) )
|
|
// InternalRDL.g:568:2: ( ( rule__EnumDefinition__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:568:2: ( ( rule__EnumDefinition__Group__0 ) )
|
|
// InternalRDL.g:569:3: ( rule__EnumDefinition__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumDefinitionAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:570:3: ( rule__EnumDefinition__Group__0 )
|
|
// InternalRDL.g:570:4: rule__EnumDefinition__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumDefinition__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumDefinitionAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleEnumDefinition"
|
|
|
|
|
|
// $ANTLR start "entryRuleEnumBody"
|
|
// InternalRDL.g:579:1: entryRuleEnumBody : ruleEnumBody EOF ;
|
|
public final void entryRuleEnumBody() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:580:1: ( ruleEnumBody EOF )
|
|
// InternalRDL.g:581:1: ruleEnumBody EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumBodyRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleEnumBody();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumBodyRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleEnumBody"
|
|
|
|
|
|
// $ANTLR start "ruleEnumBody"
|
|
// InternalRDL.g:588:1: ruleEnumBody : ( ( rule__EnumBody__Group__0 ) ) ;
|
|
public final void ruleEnumBody() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:592:2: ( ( ( rule__EnumBody__Group__0 ) ) )
|
|
// InternalRDL.g:593:2: ( ( rule__EnumBody__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:593:2: ( ( rule__EnumBody__Group__0 ) )
|
|
// InternalRDL.g:594:3: ( rule__EnumBody__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumBodyAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:595:3: ( rule__EnumBody__Group__0 )
|
|
// InternalRDL.g:595:4: rule__EnumBody__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumBody__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumBodyAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleEnumBody"
|
|
|
|
|
|
// $ANTLR start "entryRuleEnumEntry"
|
|
// InternalRDL.g:604:1: entryRuleEnumEntry : ruleEnumEntry EOF ;
|
|
public final void entryRuleEnumEntry() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:605:1: ( ruleEnumEntry EOF )
|
|
// InternalRDL.g:606:1: ruleEnumEntry EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleEnumEntry();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleEnumEntry"
|
|
|
|
|
|
// $ANTLR start "ruleEnumEntry"
|
|
// InternalRDL.g:613:1: ruleEnumEntry : ( ( rule__EnumEntry__Group__0 ) ) ;
|
|
public final void ruleEnumEntry() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:617:2: ( ( ( rule__EnumEntry__Group__0 ) ) )
|
|
// InternalRDL.g:618:2: ( ( rule__EnumEntry__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:618:2: ( ( rule__EnumEntry__Group__0 ) )
|
|
// InternalRDL.g:619:3: ( rule__EnumEntry__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:620:3: ( rule__EnumEntry__Group__0 )
|
|
// InternalRDL.g:620:4: rule__EnumEntry__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleEnumEntry"
|
|
|
|
|
|
// $ANTLR start "entryRuleEnumProperty"
|
|
// InternalRDL.g:629:1: entryRuleEnumProperty : ruleEnumProperty EOF ;
|
|
public final void entryRuleEnumProperty() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:630:1: ( ruleEnumProperty EOF )
|
|
// InternalRDL.g:631:1: ruleEnumProperty EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleEnumProperty();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleEnumProperty"
|
|
|
|
|
|
// $ANTLR start "ruleEnumProperty"
|
|
// InternalRDL.g:638:1: ruleEnumProperty : ( ( rule__EnumProperty__Group__0 ) ) ;
|
|
public final void ruleEnumProperty() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:642:2: ( ( ( rule__EnumProperty__Group__0 ) ) )
|
|
// InternalRDL.g:643:2: ( ( rule__EnumProperty__Group__0 ) )
|
|
{
|
|
// InternalRDL.g:643:2: ( ( rule__EnumProperty__Group__0 ) )
|
|
// InternalRDL.g:644:3: ( rule__EnumProperty__Group__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getGroup());
|
|
}
|
|
// InternalRDL.g:645:3: ( rule__EnumProperty__Group__0 )
|
|
// InternalRDL.g:645:4: rule__EnumProperty__Group__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__Group__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getGroup());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleEnumProperty"
|
|
|
|
|
|
// $ANTLR start "entryRuleEnumInstanceType"
|
|
// InternalRDL.g:654:1: entryRuleEnumInstanceType : ruleEnumInstanceType EOF ;
|
|
public final void entryRuleEnumInstanceType() throws RecognitionException {
|
|
try {
|
|
// InternalRDL.g:655:1: ( ruleEnumInstanceType EOF )
|
|
// InternalRDL.g:656:1: ruleEnumInstanceType EOF
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumInstanceTypeRule());
|
|
}
|
|
pushFollow(FOLLOW_1);
|
|
ruleEnumInstanceType();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumInstanceTypeRule());
|
|
}
|
|
match(input,EOF,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "entryRuleEnumInstanceType"
|
|
|
|
|
|
// $ANTLR start "ruleEnumInstanceType"
|
|
// InternalRDL.g:663:1: ruleEnumInstanceType : ( ( rule__EnumInstanceType__Alternatives ) ) ;
|
|
public final void ruleEnumInstanceType() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:667:2: ( ( ( rule__EnumInstanceType__Alternatives ) ) )
|
|
// InternalRDL.g:668:2: ( ( rule__EnumInstanceType__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:668:2: ( ( rule__EnumInstanceType__Alternatives ) )
|
|
// InternalRDL.g:669:3: ( rule__EnumInstanceType__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumInstanceTypeAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:670:3: ( rule__EnumInstanceType__Alternatives )
|
|
// InternalRDL.g:670:4: rule__EnumInstanceType__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumInstanceType__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumInstanceTypeAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleEnumInstanceType"
|
|
|
|
|
|
// $ANTLR start "rulePropertyTypeName"
|
|
// InternalRDL.g:679:1: rulePropertyTypeName : ( ( rule__PropertyTypeName__Alternatives ) ) ;
|
|
public final void rulePropertyTypeName() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:683:1: ( ( ( rule__PropertyTypeName__Alternatives ) ) )
|
|
// InternalRDL.g:684:2: ( ( rule__PropertyTypeName__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:684:2: ( ( rule__PropertyTypeName__Alternatives ) )
|
|
// InternalRDL.g:685:3: ( rule__PropertyTypeName__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyTypeNameAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:686:3: ( rule__PropertyTypeName__Alternatives )
|
|
// InternalRDL.g:686:4: rule__PropertyTypeName__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyTypeName__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyTypeNameAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rulePropertyTypeName"
|
|
|
|
|
|
// $ANTLR start "rulePropertyComponent"
|
|
// InternalRDL.g:695:1: rulePropertyComponent : ( ( rule__PropertyComponent__Alternatives ) ) ;
|
|
public final void rulePropertyComponent() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:699:1: ( ( ( rule__PropertyComponent__Alternatives ) ) )
|
|
// InternalRDL.g:700:2: ( ( rule__PropertyComponent__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:700:2: ( ( rule__PropertyComponent__Alternatives ) )
|
|
// InternalRDL.g:701:3: ( rule__PropertyComponent__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyComponentAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:702:3: ( rule__PropertyComponent__Alternatives )
|
|
// InternalRDL.g:702:4: rule__PropertyComponent__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyComponent__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyComponentAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rulePropertyComponent"
|
|
|
|
|
|
// $ANTLR start "ruleComponentDefinitionType"
|
|
// InternalRDL.g:711:1: ruleComponentDefinitionType : ( ( rule__ComponentDefinitionType__Alternatives ) ) ;
|
|
public final void ruleComponentDefinitionType() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:715:1: ( ( ( rule__ComponentDefinitionType__Alternatives ) ) )
|
|
// InternalRDL.g:716:2: ( ( rule__ComponentDefinitionType__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:716:2: ( ( rule__ComponentDefinitionType__Alternatives ) )
|
|
// InternalRDL.g:717:3: ( rule__ComponentDefinitionType__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionTypeAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:718:3: ( rule__ComponentDefinitionType__Alternatives )
|
|
// InternalRDL.g:718:4: rule__ComponentDefinitionType__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinitionType__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionTypeAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleComponentDefinitionType"
|
|
|
|
|
|
// $ANTLR start "ruleProperty"
|
|
// InternalRDL.g:727:1: ruleProperty : ( ( rule__Property__Alternatives ) ) ;
|
|
public final void ruleProperty() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:731:1: ( ( ( rule__Property__Alternatives ) ) )
|
|
// InternalRDL.g:732:2: ( ( rule__Property__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:732:2: ( ( rule__Property__Alternatives ) )
|
|
// InternalRDL.g:733:3: ( rule__Property__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:734:3: ( rule__Property__Alternatives )
|
|
// InternalRDL.g:734:4: rule__Property__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Property__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleProperty"
|
|
|
|
|
|
// $ANTLR start "ruleRValueConstant"
|
|
// InternalRDL.g:743:1: ruleRValueConstant : ( ( rule__RValueConstant__Alternatives ) ) ;
|
|
public final void ruleRValueConstant() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:747:1: ( ( ( rule__RValueConstant__Alternatives ) ) )
|
|
// InternalRDL.g:748:2: ( ( rule__RValueConstant__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:748:2: ( ( rule__RValueConstant__Alternatives ) )
|
|
// InternalRDL.g:749:3: ( rule__RValueConstant__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:750:3: ( rule__RValueConstant__Alternatives )
|
|
// InternalRDL.g:750:4: rule__RValueConstant__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__RValueConstant__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "ruleRValueConstant"
|
|
|
|
|
|
// $ANTLR start "rulePropertyModifier"
|
|
// InternalRDL.g:759:1: rulePropertyModifier : ( ( rule__PropertyModifier__Alternatives ) ) ;
|
|
public final void rulePropertyModifier() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:763:1: ( ( ( rule__PropertyModifier__Alternatives ) ) )
|
|
// InternalRDL.g:764:2: ( ( rule__PropertyModifier__Alternatives ) )
|
|
{
|
|
// InternalRDL.g:764:2: ( ( rule__PropertyModifier__Alternatives ) )
|
|
// InternalRDL.g:765:3: ( rule__PropertyModifier__Alternatives )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyModifierAccess().getAlternatives());
|
|
}
|
|
// InternalRDL.g:766:3: ( rule__PropertyModifier__Alternatives )
|
|
// InternalRDL.g:766:4: rule__PropertyModifier__Alternatives
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyModifier__Alternatives();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyModifierAccess().getAlternatives());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rulePropertyModifier"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Alternatives"
|
|
// InternalRDL.g:774:1: rule__Root__Alternatives : ( ( ( rule__Root__IncludesAssignment_0 ) ) | ( ( rule__Root__Group_1__0 ) ) | ( ( rule__Root__Group_2__0 ) ) | ( ( rule__Root__Group_3__0 ) ) | ( ( rule__Root__Group_4__0 ) ) | ( ( rule__Root__Group_5__0 ) ) );
|
|
public final void rule__Root__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:778:1: ( ( ( rule__Root__IncludesAssignment_0 ) ) | ( ( rule__Root__Group_1__0 ) ) | ( ( rule__Root__Group_2__0 ) ) | ( ( rule__Root__Group_3__0 ) ) | ( ( rule__Root__Group_4__0 ) ) | ( ( rule__Root__Group_5__0 ) ) )
|
|
int alt2=6;
|
|
alt2 = dfa2.predict(input);
|
|
switch (alt2) {
|
|
case 1 :
|
|
// InternalRDL.g:779:2: ( ( rule__Root__IncludesAssignment_0 ) )
|
|
{
|
|
// InternalRDL.g:779:2: ( ( rule__Root__IncludesAssignment_0 ) )
|
|
// InternalRDL.g:780:3: ( rule__Root__IncludesAssignment_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getIncludesAssignment_0());
|
|
}
|
|
// InternalRDL.g:781:3: ( rule__Root__IncludesAssignment_0 )
|
|
// InternalRDL.g:781:4: rule__Root__IncludesAssignment_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__IncludesAssignment_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getIncludesAssignment_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:785:2: ( ( rule__Root__Group_1__0 ) )
|
|
{
|
|
// InternalRDL.g:785:2: ( ( rule__Root__Group_1__0 ) )
|
|
// InternalRDL.g:786:3: ( rule__Root__Group_1__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getGroup_1());
|
|
}
|
|
// InternalRDL.g:787:3: ( rule__Root__Group_1__0 )
|
|
// InternalRDL.g:787:4: rule__Root__Group_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getGroup_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:791:2: ( ( rule__Root__Group_2__0 ) )
|
|
{
|
|
// InternalRDL.g:791:2: ( ( rule__Root__Group_2__0 ) )
|
|
// InternalRDL.g:792:3: ( rule__Root__Group_2__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getGroup_2());
|
|
}
|
|
// InternalRDL.g:793:3: ( rule__Root__Group_2__0 )
|
|
// InternalRDL.g:793:4: rule__Root__Group_2__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_2__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getGroup_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:797:2: ( ( rule__Root__Group_3__0 ) )
|
|
{
|
|
// InternalRDL.g:797:2: ( ( rule__Root__Group_3__0 ) )
|
|
// InternalRDL.g:798:3: ( rule__Root__Group_3__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getGroup_3());
|
|
}
|
|
// InternalRDL.g:799:3: ( rule__Root__Group_3__0 )
|
|
// InternalRDL.g:799:4: rule__Root__Group_3__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_3__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getGroup_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 5 :
|
|
// InternalRDL.g:803:2: ( ( rule__Root__Group_4__0 ) )
|
|
{
|
|
// InternalRDL.g:803:2: ( ( rule__Root__Group_4__0 ) )
|
|
// InternalRDL.g:804:3: ( rule__Root__Group_4__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getGroup_4());
|
|
}
|
|
// InternalRDL.g:805:3: ( rule__Root__Group_4__0 )
|
|
// InternalRDL.g:805:4: rule__Root__Group_4__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_4__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getGroup_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 6 :
|
|
// InternalRDL.g:809:2: ( ( rule__Root__Group_5__0 ) )
|
|
{
|
|
// InternalRDL.g:809:2: ( ( rule__Root__Group_5__0 ) )
|
|
// InternalRDL.g:810:3: ( rule__Root__Group_5__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getGroup_5());
|
|
}
|
|
// InternalRDL.g:811:3: ( rule__Root__Group_5__0 )
|
|
// InternalRDL.g:811:4: rule__Root__Group_5__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_5__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getGroup_5());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Alternatives_3"
|
|
// InternalRDL.g:819:1: rule__PropertyDefinition__Alternatives_3 : ( ( ( rule__PropertyDefinition__Group_3_0__0 ) ) | ( ( rule__PropertyDefinition__Group_3_1__0 ) ) | ( ( rule__PropertyDefinition__Group_3_2__0 ) ) );
|
|
public final void rule__PropertyDefinition__Alternatives_3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:823:1: ( ( ( rule__PropertyDefinition__Group_3_0__0 ) ) | ( ( rule__PropertyDefinition__Group_3_1__0 ) ) | ( ( rule__PropertyDefinition__Group_3_2__0 ) ) )
|
|
int alt3=3;
|
|
switch ( input.LA(1) ) {
|
|
case 118:
|
|
{
|
|
alt3=1;
|
|
}
|
|
break;
|
|
case 121:
|
|
{
|
|
alt3=2;
|
|
}
|
|
break;
|
|
case 120:
|
|
{
|
|
alt3=3;
|
|
}
|
|
break;
|
|
default:
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 3, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt3) {
|
|
case 1 :
|
|
// InternalRDL.g:824:2: ( ( rule__PropertyDefinition__Group_3_0__0 ) )
|
|
{
|
|
// InternalRDL.g:824:2: ( ( rule__PropertyDefinition__Group_3_0__0 ) )
|
|
// InternalRDL.g:825:3: ( rule__PropertyDefinition__Group_3_0__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getGroup_3_0());
|
|
}
|
|
// InternalRDL.g:826:3: ( rule__PropertyDefinition__Group_3_0__0 )
|
|
// InternalRDL.g:826:4: rule__PropertyDefinition__Group_3_0__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getGroup_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:830:2: ( ( rule__PropertyDefinition__Group_3_1__0 ) )
|
|
{
|
|
// InternalRDL.g:830:2: ( ( rule__PropertyDefinition__Group_3_1__0 ) )
|
|
// InternalRDL.g:831:3: ( rule__PropertyDefinition__Group_3_1__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getGroup_3_1());
|
|
}
|
|
// InternalRDL.g:832:3: ( rule__PropertyDefinition__Group_3_1__0 )
|
|
// InternalRDL.g:832:4: rule__PropertyDefinition__Group_3_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getGroup_3_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:836:2: ( ( rule__PropertyDefinition__Group_3_2__0 ) )
|
|
{
|
|
// InternalRDL.g:836:2: ( ( rule__PropertyDefinition__Group_3_2__0 ) )
|
|
// InternalRDL.g:837:3: ( rule__PropertyDefinition__Group_3_2__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getGroup_3_2());
|
|
}
|
|
// InternalRDL.g:838:3: ( rule__PropertyDefinition__Group_3_2__0 )
|
|
// InternalRDL.g:838:4: rule__PropertyDefinition__Group_3_2__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getGroup_3_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Alternatives_3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Alternatives_3_0_4"
|
|
// InternalRDL.g:846:1: rule__PropertyDefinition__Alternatives_3_0_4 : ( ( ( rule__PropertyDefinition__Group_3_0_4_0__0 ) ) | ( ( rule__PropertyDefinition__Group_3_0_4_1__0 ) ) );
|
|
public final void rule__PropertyDefinition__Alternatives_3_0_4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:850:1: ( ( ( rule__PropertyDefinition__Group_3_0_4_0__0 ) ) | ( ( rule__PropertyDefinition__Group_3_0_4_1__0 ) ) )
|
|
int alt4=2;
|
|
int LA4_0 = input.LA(1);
|
|
|
|
if ( (LA4_0==121) ) {
|
|
alt4=1;
|
|
}
|
|
else if ( (LA4_0==120) ) {
|
|
alt4=2;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 4, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt4) {
|
|
case 1 :
|
|
// InternalRDL.g:851:2: ( ( rule__PropertyDefinition__Group_3_0_4_0__0 ) )
|
|
{
|
|
// InternalRDL.g:851:2: ( ( rule__PropertyDefinition__Group_3_0_4_0__0 ) )
|
|
// InternalRDL.g:852:3: ( rule__PropertyDefinition__Group_3_0_4_0__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getGroup_3_0_4_0());
|
|
}
|
|
// InternalRDL.g:853:3: ( rule__PropertyDefinition__Group_3_0_4_0__0 )
|
|
// InternalRDL.g:853:4: rule__PropertyDefinition__Group_3_0_4_0__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0_4_0__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getGroup_3_0_4_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:857:2: ( ( rule__PropertyDefinition__Group_3_0_4_1__0 ) )
|
|
{
|
|
// InternalRDL.g:857:2: ( ( rule__PropertyDefinition__Group_3_0_4_1__0 ) )
|
|
// InternalRDL.g:858:3: ( rule__PropertyDefinition__Group_3_0_4_1__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getGroup_3_0_4_1());
|
|
}
|
|
// InternalRDL.g:859:3: ( rule__PropertyDefinition__Group_3_0_4_1__0 )
|
|
// InternalRDL.g:859:4: rule__PropertyDefinition__Group_3_0_4_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0_4_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getGroup_3_0_4_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Alternatives_3_0_4"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Alternatives_3_1_1"
|
|
// InternalRDL.g:867:1: rule__PropertyDefinition__Alternatives_3_1_1 : ( ( ( rule__PropertyDefinition__Group_3_1_1_0__0 ) ) | ( ( rule__PropertyDefinition__Group_3_1_1_1__0 ) ) );
|
|
public final void rule__PropertyDefinition__Alternatives_3_1_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:871:1: ( ( ( rule__PropertyDefinition__Group_3_1_1_0__0 ) ) | ( ( rule__PropertyDefinition__Group_3_1_1_1__0 ) ) )
|
|
int alt5=2;
|
|
int LA5_0 = input.LA(1);
|
|
|
|
if ( (LA5_0==118) ) {
|
|
alt5=1;
|
|
}
|
|
else if ( (LA5_0==120) ) {
|
|
alt5=2;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 5, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt5) {
|
|
case 1 :
|
|
// InternalRDL.g:872:2: ( ( rule__PropertyDefinition__Group_3_1_1_0__0 ) )
|
|
{
|
|
// InternalRDL.g:872:2: ( ( rule__PropertyDefinition__Group_3_1_1_0__0 ) )
|
|
// InternalRDL.g:873:3: ( rule__PropertyDefinition__Group_3_1_1_0__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getGroup_3_1_1_0());
|
|
}
|
|
// InternalRDL.g:874:3: ( rule__PropertyDefinition__Group_3_1_1_0__0 )
|
|
// InternalRDL.g:874:4: rule__PropertyDefinition__Group_3_1_1_0__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_0__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getGroup_3_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:878:2: ( ( rule__PropertyDefinition__Group_3_1_1_1__0 ) )
|
|
{
|
|
// InternalRDL.g:878:2: ( ( rule__PropertyDefinition__Group_3_1_1_1__0 ) )
|
|
// InternalRDL.g:879:3: ( rule__PropertyDefinition__Group_3_1_1_1__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getGroup_3_1_1_1());
|
|
}
|
|
// InternalRDL.g:880:3: ( rule__PropertyDefinition__Group_3_1_1_1__0 )
|
|
// InternalRDL.g:880:4: rule__PropertyDefinition__Group_3_1_1_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getGroup_3_1_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Alternatives_3_1_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Alternatives_3_2_1"
|
|
// InternalRDL.g:888:1: rule__PropertyDefinition__Alternatives_3_2_1 : ( ( ( rule__PropertyDefinition__Group_3_2_1_0__0 ) ) | ( ( rule__PropertyDefinition__Group_3_2_1_1__0 ) ) );
|
|
public final void rule__PropertyDefinition__Alternatives_3_2_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:892:1: ( ( ( rule__PropertyDefinition__Group_3_2_1_0__0 ) ) | ( ( rule__PropertyDefinition__Group_3_2_1_1__0 ) ) )
|
|
int alt6=2;
|
|
int LA6_0 = input.LA(1);
|
|
|
|
if ( (LA6_0==118) ) {
|
|
alt6=1;
|
|
}
|
|
else if ( (LA6_0==121) ) {
|
|
alt6=2;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 6, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt6) {
|
|
case 1 :
|
|
// InternalRDL.g:893:2: ( ( rule__PropertyDefinition__Group_3_2_1_0__0 ) )
|
|
{
|
|
// InternalRDL.g:893:2: ( ( rule__PropertyDefinition__Group_3_2_1_0__0 ) )
|
|
// InternalRDL.g:894:3: ( rule__PropertyDefinition__Group_3_2_1_0__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getGroup_3_2_1_0());
|
|
}
|
|
// InternalRDL.g:895:3: ( rule__PropertyDefinition__Group_3_2_1_0__0 )
|
|
// InternalRDL.g:895:4: rule__PropertyDefinition__Group_3_2_1_0__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_0__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getGroup_3_2_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:899:2: ( ( rule__PropertyDefinition__Group_3_2_1_1__0 ) )
|
|
{
|
|
// InternalRDL.g:899:2: ( ( rule__PropertyDefinition__Group_3_2_1_1__0 ) )
|
|
// InternalRDL.g:900:3: ( rule__PropertyDefinition__Group_3_2_1_1__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getGroup_3_2_1_1());
|
|
}
|
|
// InternalRDL.g:901:3: ( rule__PropertyDefinition__Group_3_2_1_1__0 )
|
|
// InternalRDL.g:901:4: rule__PropertyDefinition__Group_3_2_1_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getGroup_3_2_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Alternatives_3_2_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__Alternatives_2"
|
|
// InternalRDL.g:909:1: rule__PropertyDefault__Alternatives_2 : ( ( ( rule__PropertyDefault__StringAssignment_2_0 ) ) | ( ( rule__PropertyDefault__ValueAssignment_2_1 ) ) | ( ( rule__PropertyDefault__StringAssignment_2_2 ) ) | ( ( rule__PropertyDefault__StringAssignment_2_3 ) ) );
|
|
public final void rule__PropertyDefault__Alternatives_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:913:1: ( ( ( rule__PropertyDefault__StringAssignment_2_0 ) ) | ( ( rule__PropertyDefault__ValueAssignment_2_1 ) ) | ( ( rule__PropertyDefault__StringAssignment_2_2 ) ) | ( ( rule__PropertyDefault__StringAssignment_2_3 ) ) )
|
|
int alt7=4;
|
|
switch ( input.LA(1) ) {
|
|
case RULE_STR:
|
|
{
|
|
alt7=1;
|
|
}
|
|
break;
|
|
case RULE_NUM:
|
|
{
|
|
alt7=2;
|
|
}
|
|
break;
|
|
case 98:
|
|
{
|
|
alt7=3;
|
|
}
|
|
break;
|
|
case 99:
|
|
{
|
|
alt7=4;
|
|
}
|
|
break;
|
|
default:
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 7, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt7) {
|
|
case 1 :
|
|
// InternalRDL.g:914:2: ( ( rule__PropertyDefault__StringAssignment_2_0 ) )
|
|
{
|
|
// InternalRDL.g:914:2: ( ( rule__PropertyDefault__StringAssignment_2_0 ) )
|
|
// InternalRDL.g:915:3: ( rule__PropertyDefault__StringAssignment_2_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getStringAssignment_2_0());
|
|
}
|
|
// InternalRDL.g:916:3: ( rule__PropertyDefault__StringAssignment_2_0 )
|
|
// InternalRDL.g:916:4: rule__PropertyDefault__StringAssignment_2_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefault__StringAssignment_2_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getStringAssignment_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:920:2: ( ( rule__PropertyDefault__ValueAssignment_2_1 ) )
|
|
{
|
|
// InternalRDL.g:920:2: ( ( rule__PropertyDefault__ValueAssignment_2_1 ) )
|
|
// InternalRDL.g:921:3: ( rule__PropertyDefault__ValueAssignment_2_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getValueAssignment_2_1());
|
|
}
|
|
// InternalRDL.g:922:3: ( rule__PropertyDefault__ValueAssignment_2_1 )
|
|
// InternalRDL.g:922:4: rule__PropertyDefault__ValueAssignment_2_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefault__ValueAssignment_2_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getValueAssignment_2_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:926:2: ( ( rule__PropertyDefault__StringAssignment_2_2 ) )
|
|
{
|
|
// InternalRDL.g:926:2: ( ( rule__PropertyDefault__StringAssignment_2_2 ) )
|
|
// InternalRDL.g:927:3: ( rule__PropertyDefault__StringAssignment_2_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getStringAssignment_2_2());
|
|
}
|
|
// InternalRDL.g:928:3: ( rule__PropertyDefault__StringAssignment_2_2 )
|
|
// InternalRDL.g:928:4: rule__PropertyDefault__StringAssignment_2_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefault__StringAssignment_2_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getStringAssignment_2_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:932:2: ( ( rule__PropertyDefault__StringAssignment_2_3 ) )
|
|
{
|
|
// InternalRDL.g:932:2: ( ( rule__PropertyDefault__StringAssignment_2_3 ) )
|
|
// InternalRDL.g:933:3: ( rule__PropertyDefault__StringAssignment_2_3 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getStringAssignment_2_3());
|
|
}
|
|
// InternalRDL.g:934:3: ( rule__PropertyDefault__StringAssignment_2_3 )
|
|
// InternalRDL.g:934:4: rule__PropertyDefault__StringAssignment_2_3
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefault__StringAssignment_2_3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getStringAssignment_2_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__Alternatives_2"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Alternatives_3"
|
|
// InternalRDL.g:942:1: rule__ComponentDefinition__Alternatives_3 : ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) | ( ( rule__ComponentDefinition__Group_3_1__0 ) ) | ( ( rule__ComponentDefinition__Group_3_2__0 ) ) | ( ( rule__ComponentDefinition__Group_3_3__0 ) ) );
|
|
public final void rule__ComponentDefinition__Alternatives_3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:946:1: ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) | ( ( rule__ComponentDefinition__Group_3_1__0 ) ) | ( ( rule__ComponentDefinition__Group_3_2__0 ) ) | ( ( rule__ComponentDefinition__Group_3_3__0 ) ) )
|
|
int alt8=4;
|
|
alt8 = dfa8.predict(input);
|
|
switch (alt8) {
|
|
case 1 :
|
|
// InternalRDL.g:947:2: ( ( rule__ComponentDefinition__Group_3_0__0 ) )
|
|
{
|
|
// InternalRDL.g:947:2: ( ( rule__ComponentDefinition__Group_3_0__0 ) )
|
|
// InternalRDL.g:948:3: ( rule__ComponentDefinition__Group_3_0__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getGroup_3_0());
|
|
}
|
|
// InternalRDL.g:949:3: ( rule__ComponentDefinition__Group_3_0__0 )
|
|
// InternalRDL.g:949:4: rule__ComponentDefinition__Group_3_0__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_0__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getGroup_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:953:2: ( ( rule__ComponentDefinition__Group_3_1__0 ) )
|
|
{
|
|
// InternalRDL.g:953:2: ( ( rule__ComponentDefinition__Group_3_1__0 ) )
|
|
// InternalRDL.g:954:3: ( rule__ComponentDefinition__Group_3_1__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getGroup_3_1());
|
|
}
|
|
// InternalRDL.g:955:3: ( rule__ComponentDefinition__Group_3_1__0 )
|
|
// InternalRDL.g:955:4: rule__ComponentDefinition__Group_3_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getGroup_3_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:959:2: ( ( rule__ComponentDefinition__Group_3_2__0 ) )
|
|
{
|
|
// InternalRDL.g:959:2: ( ( rule__ComponentDefinition__Group_3_2__0 ) )
|
|
// InternalRDL.g:960:3: ( rule__ComponentDefinition__Group_3_2__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getGroup_3_2());
|
|
}
|
|
// InternalRDL.g:961:3: ( rule__ComponentDefinition__Group_3_2__0 )
|
|
// InternalRDL.g:961:4: rule__ComponentDefinition__Group_3_2__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_2__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getGroup_3_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:965:2: ( ( rule__ComponentDefinition__Group_3_3__0 ) )
|
|
{
|
|
// InternalRDL.g:965:2: ( ( rule__ComponentDefinition__Group_3_3__0 ) )
|
|
// InternalRDL.g:966:3: ( rule__ComponentDefinition__Group_3_3__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getGroup_3_3());
|
|
}
|
|
// InternalRDL.g:967:3: ( rule__ComponentDefinition__Group_3_3__0 )
|
|
// InternalRDL.g:967:4: rule__ComponentDefinition__Group_3_3__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_3__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getGroup_3_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Alternatives_3"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Alternatives_0"
|
|
// InternalRDL.g:975:1: rule__Instantiation__Alternatives_0 : ( ( ( rule__Instantiation__Group_0_0__0 ) ) | ( ( rule__Instantiation__Group_0_1__0 ) ) );
|
|
public final void rule__Instantiation__Alternatives_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:979:1: ( ( ( rule__Instantiation__Group_0_0__0 ) ) | ( ( rule__Instantiation__Group_0_1__0 ) ) )
|
|
int alt9=2;
|
|
int LA9_0 = input.LA(1);
|
|
|
|
if ( (LA9_0==RULE_ID||LA9_0==76||LA9_0==123||LA9_0==134) ) {
|
|
alt9=1;
|
|
}
|
|
else if ( ((LA9_0>=15 && LA9_0<=18)||LA9_0==20) ) {
|
|
alt9=2;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 9, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt9) {
|
|
case 1 :
|
|
// InternalRDL.g:980:2: ( ( rule__Instantiation__Group_0_0__0 ) )
|
|
{
|
|
// InternalRDL.g:980:2: ( ( rule__Instantiation__Group_0_0__0 ) )
|
|
// InternalRDL.g:981:3: ( rule__Instantiation__Group_0_0__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getGroup_0_0());
|
|
}
|
|
// InternalRDL.g:982:3: ( rule__Instantiation__Group_0_0__0 )
|
|
// InternalRDL.g:982:4: rule__Instantiation__Group_0_0__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group_0_0__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getGroup_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:986:2: ( ( rule__Instantiation__Group_0_1__0 ) )
|
|
{
|
|
// InternalRDL.g:986:2: ( ( rule__Instantiation__Group_0_1__0 ) )
|
|
// InternalRDL.g:987:3: ( rule__Instantiation__Group_0_1__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getGroup_0_1());
|
|
}
|
|
// InternalRDL.g:988:3: ( rule__Instantiation__Group_0_1__0 )
|
|
// InternalRDL.g:988:4: rule__Instantiation__Group_0_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group_0_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getGroup_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Alternatives_0"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Alternatives_1"
|
|
// InternalRDL.g:996:1: rule__Range__Alternatives_1 : ( ( ( rule__Range__Group_1_0__0 ) ) | ( ( rule__Range__SizeAssignment_1_1 ) ) );
|
|
public final void rule__Range__Alternatives_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1000:1: ( ( ( rule__Range__Group_1_0__0 ) ) | ( ( rule__Range__SizeAssignment_1_1 ) ) )
|
|
int alt10=2;
|
|
int LA10_0 = input.LA(1);
|
|
|
|
if ( (LA10_0==RULE_NUM) ) {
|
|
int LA10_1 = input.LA(2);
|
|
|
|
if ( (LA10_1==130) ) {
|
|
alt10=1;
|
|
}
|
|
else if ( (LA10_1==129) ) {
|
|
alt10=2;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 10, 1, input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 10, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt10) {
|
|
case 1 :
|
|
// InternalRDL.g:1001:2: ( ( rule__Range__Group_1_0__0 ) )
|
|
{
|
|
// InternalRDL.g:1001:2: ( ( rule__Range__Group_1_0__0 ) )
|
|
// InternalRDL.g:1002:3: ( rule__Range__Group_1_0__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getGroup_1_0());
|
|
}
|
|
// InternalRDL.g:1003:3: ( rule__Range__Group_1_0__0 )
|
|
// InternalRDL.g:1003:4: rule__Range__Group_1_0__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__Group_1_0__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getGroup_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1007:2: ( ( rule__Range__SizeAssignment_1_1 ) )
|
|
{
|
|
// InternalRDL.g:1007:2: ( ( rule__Range__SizeAssignment_1_1 ) )
|
|
// InternalRDL.g:1008:3: ( rule__Range__SizeAssignment_1_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getSizeAssignment_1_1());
|
|
}
|
|
// InternalRDL.g:1009:3: ( rule__Range__SizeAssignment_1_1 )
|
|
// InternalRDL.g:1009:4: rule__Range__SizeAssignment_1_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__SizeAssignment_1_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getSizeAssignment_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__Alternatives_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignment__Alternatives"
|
|
// InternalRDL.g:1017:1: rule__PropertyAssignment__Alternatives : ( ( ruleDefaultProperyAssignment ) | ( ruleExplicitPropertyAssignment ) | ( rulePostPropertyAssignment ) );
|
|
public final void rule__PropertyAssignment__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1021:1: ( ( ruleDefaultProperyAssignment ) | ( ruleExplicitPropertyAssignment ) | ( rulePostPropertyAssignment ) )
|
|
int alt11=3;
|
|
switch ( input.LA(1) ) {
|
|
case 120:
|
|
{
|
|
alt11=1;
|
|
}
|
|
break;
|
|
case 22:
|
|
case 23:
|
|
case 24:
|
|
case 25:
|
|
case 26:
|
|
case 27:
|
|
case 28:
|
|
case 29:
|
|
case 30:
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 36:
|
|
case 37:
|
|
case 38:
|
|
case 39:
|
|
case 40:
|
|
case 41:
|
|
case 42:
|
|
case 43:
|
|
case 44:
|
|
case 45:
|
|
case 46:
|
|
case 47:
|
|
case 48:
|
|
case 49:
|
|
case 50:
|
|
case 51:
|
|
case 52:
|
|
case 53:
|
|
case 54:
|
|
case 55:
|
|
case 56:
|
|
case 57:
|
|
case 58:
|
|
case 59:
|
|
case 60:
|
|
case 61:
|
|
case 62:
|
|
case 63:
|
|
case 64:
|
|
case 65:
|
|
case 66:
|
|
case 67:
|
|
case 68:
|
|
case 69:
|
|
case 70:
|
|
case 71:
|
|
case 72:
|
|
case 73:
|
|
case 74:
|
|
case 75:
|
|
case 76:
|
|
case 77:
|
|
case 78:
|
|
case 79:
|
|
case 80:
|
|
case 81:
|
|
case 82:
|
|
case 83:
|
|
case 84:
|
|
case 85:
|
|
case 86:
|
|
case 87:
|
|
case 88:
|
|
case 89:
|
|
case 90:
|
|
case 91:
|
|
case 92:
|
|
case 93:
|
|
case 94:
|
|
case 95:
|
|
case 96:
|
|
case 97:
|
|
case 108:
|
|
case 109:
|
|
case 110:
|
|
case 111:
|
|
case 112:
|
|
{
|
|
alt11=2;
|
|
}
|
|
break;
|
|
case RULE_ID:
|
|
{
|
|
alt11=3;
|
|
}
|
|
break;
|
|
default:
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 11, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt11) {
|
|
case 1 :
|
|
// InternalRDL.g:1022:2: ( ruleDefaultProperyAssignment )
|
|
{
|
|
// InternalRDL.g:1022:2: ( ruleDefaultProperyAssignment )
|
|
// InternalRDL.g:1023:3: ruleDefaultProperyAssignment
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentAccess().getDefaultProperyAssignmentParserRuleCall_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleDefaultProperyAssignment();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentAccess().getDefaultProperyAssignmentParserRuleCall_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1028:2: ( ruleExplicitPropertyAssignment )
|
|
{
|
|
// InternalRDL.g:1028:2: ( ruleExplicitPropertyAssignment )
|
|
// InternalRDL.g:1029:3: ruleExplicitPropertyAssignment
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentAccess().getExplicitPropertyAssignmentParserRuleCall_1());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleExplicitPropertyAssignment();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentAccess().getExplicitPropertyAssignmentParserRuleCall_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:1034:2: ( rulePostPropertyAssignment )
|
|
{
|
|
// InternalRDL.g:1034:2: ( rulePostPropertyAssignment )
|
|
// InternalRDL.g:1035:3: rulePostPropertyAssignment
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentAccess().getPostPropertyAssignmentParserRuleCall_2());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePostPropertyAssignment();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentAccess().getPostPropertyAssignmentParserRuleCall_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignment__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Alternatives"
|
|
// InternalRDL.g:1044:1: rule__ExplicitPropertyAssignment__Alternatives : ( ( ( rule__ExplicitPropertyAssignment__Group_0__0 ) ) | ( ( rule__ExplicitPropertyAssignment__Group_1__0 ) ) );
|
|
public final void rule__ExplicitPropertyAssignment__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1048:1: ( ( ( rule__ExplicitPropertyAssignment__Group_0__0 ) ) | ( ( rule__ExplicitPropertyAssignment__Group_1__0 ) ) )
|
|
int alt12=2;
|
|
int LA12_0 = input.LA(1);
|
|
|
|
if ( (LA12_0==97||(LA12_0>=108 && LA12_0<=112)) ) {
|
|
alt12=1;
|
|
}
|
|
else if ( ((LA12_0>=22 && LA12_0<=96)) ) {
|
|
alt12=2;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 12, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt12) {
|
|
case 1 :
|
|
// InternalRDL.g:1049:2: ( ( rule__ExplicitPropertyAssignment__Group_0__0 ) )
|
|
{
|
|
// InternalRDL.g:1049:2: ( ( rule__ExplicitPropertyAssignment__Group_0__0 ) )
|
|
// InternalRDL.g:1050:3: ( rule__ExplicitPropertyAssignment__Group_0__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getGroup_0());
|
|
}
|
|
// InternalRDL.g:1051:3: ( rule__ExplicitPropertyAssignment__Group_0__0 )
|
|
// InternalRDL.g:1051:4: rule__ExplicitPropertyAssignment__Group_0__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__Group_0__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getGroup_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1055:2: ( ( rule__ExplicitPropertyAssignment__Group_1__0 ) )
|
|
{
|
|
// InternalRDL.g:1055:2: ( ( rule__ExplicitPropertyAssignment__Group_1__0 ) )
|
|
// InternalRDL.g:1056:3: ( rule__ExplicitPropertyAssignment__Group_1__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getGroup_1());
|
|
}
|
|
// InternalRDL.g:1057:3: ( rule__ExplicitPropertyAssignment__Group_1__0 )
|
|
// InternalRDL.g:1057:4: rule__ExplicitPropertyAssignment__Group_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__Group_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getGroup_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Alternatives_0"
|
|
// InternalRDL.g:1065:1: rule__PostPropertyAssignment__Alternatives_0 : ( ( ( rule__PostPropertyAssignment__Group_0_0__0 ) ) | ( ( rule__PostPropertyAssignment__PropertyAssignment_0_1 ) ) );
|
|
public final void rule__PostPropertyAssignment__Alternatives_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1069:1: ( ( ( rule__PostPropertyAssignment__Group_0_0__0 ) ) | ( ( rule__PostPropertyAssignment__PropertyAssignment_0_1 ) ) )
|
|
int alt13=2;
|
|
int LA13_0 = input.LA(1);
|
|
|
|
if ( (LA13_0==RULE_ID) ) {
|
|
int LA13_1 = input.LA(2);
|
|
|
|
if ( (LA13_1==EOF||LA13_1==113||LA13_1==119) ) {
|
|
alt13=2;
|
|
}
|
|
else if ( ((LA13_1>=131 && LA13_1<=132)) ) {
|
|
alt13=1;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 13, 1, input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 13, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt13) {
|
|
case 1 :
|
|
// InternalRDL.g:1070:2: ( ( rule__PostPropertyAssignment__Group_0_0__0 ) )
|
|
{
|
|
// InternalRDL.g:1070:2: ( ( rule__PostPropertyAssignment__Group_0_0__0 ) )
|
|
// InternalRDL.g:1071:3: ( rule__PostPropertyAssignment__Group_0_0__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getGroup_0_0());
|
|
}
|
|
// InternalRDL.g:1072:3: ( rule__PostPropertyAssignment__Group_0_0__0 )
|
|
// InternalRDL.g:1072:4: rule__PostPropertyAssignment__Group_0_0__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__Group_0_0__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getGroup_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1076:2: ( ( rule__PostPropertyAssignment__PropertyAssignment_0_1 ) )
|
|
{
|
|
// InternalRDL.g:1076:2: ( ( rule__PostPropertyAssignment__PropertyAssignment_0_1 ) )
|
|
// InternalRDL.g:1077:3: ( rule__PostPropertyAssignment__PropertyAssignment_0_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getPropertyAssignment_0_1());
|
|
}
|
|
// InternalRDL.g:1078:3: ( rule__PostPropertyAssignment__PropertyAssignment_0_1 )
|
|
// InternalRDL.g:1078:4: rule__PostPropertyAssignment__PropertyAssignment_0_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__PropertyAssignment_0_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getPropertyAssignment_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Alternatives_0"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Alternatives_0_0_2"
|
|
// InternalRDL.g:1086:1: rule__PostPropertyAssignment__Alternatives_0_0_2 : ( ( ( rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0 ) ) | ( ( rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1 ) ) );
|
|
public final void rule__PostPropertyAssignment__Alternatives_0_0_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1090:1: ( ( ( rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0 ) ) | ( ( rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1 ) ) )
|
|
int alt14=2;
|
|
int LA14_0 = input.LA(1);
|
|
|
|
if ( ((LA14_0>=22 && LA14_0<=96)) ) {
|
|
alt14=1;
|
|
}
|
|
else if ( (LA14_0==RULE_ID) ) {
|
|
alt14=2;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 14, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt14) {
|
|
case 1 :
|
|
// InternalRDL.g:1091:2: ( ( rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0 ) )
|
|
{
|
|
// InternalRDL.g:1091:2: ( ( rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0 ) )
|
|
// InternalRDL.g:1092:3: ( rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getPropertyEnumAssignment_0_0_2_0());
|
|
}
|
|
// InternalRDL.g:1093:3: ( rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0 )
|
|
// InternalRDL.g:1093:4: rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getPropertyEnumAssignment_0_0_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1097:2: ( ( rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1 ) )
|
|
{
|
|
// InternalRDL.g:1097:2: ( ( rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1 ) )
|
|
// InternalRDL.g:1098:3: ( rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getPropertyAssignment_0_0_2_1());
|
|
}
|
|
// InternalRDL.g:1099:3: ( rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1 )
|
|
// InternalRDL.g:1099:4: rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getPropertyAssignment_0_0_2_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Alternatives_0_0_2"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__Alternatives_1_1"
|
|
// InternalRDL.g:1107:1: rule__InstancePropertyRef__Alternatives_1_1 : ( ( ( rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0 ) ) | ( ( rule__InstancePropertyRef__PropertyAssignment_1_1_1 ) ) );
|
|
public final void rule__InstancePropertyRef__Alternatives_1_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1111:1: ( ( ( rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0 ) ) | ( ( rule__InstancePropertyRef__PropertyAssignment_1_1_1 ) ) )
|
|
int alt15=2;
|
|
int LA15_0 = input.LA(1);
|
|
|
|
if ( ((LA15_0>=22 && LA15_0<=96)) ) {
|
|
alt15=1;
|
|
}
|
|
else if ( (LA15_0==RULE_ID) ) {
|
|
alt15=2;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 15, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt15) {
|
|
case 1 :
|
|
// InternalRDL.g:1112:2: ( ( rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0 ) )
|
|
{
|
|
// InternalRDL.g:1112:2: ( ( rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0 ) )
|
|
// InternalRDL.g:1113:3: ( rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefAccess().getPropertyEnumAssignment_1_1_0());
|
|
}
|
|
// InternalRDL.g:1114:3: ( rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0 )
|
|
// InternalRDL.g:1114:4: rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefAccess().getPropertyEnumAssignment_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1118:2: ( ( rule__InstancePropertyRef__PropertyAssignment_1_1_1 ) )
|
|
{
|
|
// InternalRDL.g:1118:2: ( ( rule__InstancePropertyRef__PropertyAssignment_1_1_1 ) )
|
|
// InternalRDL.g:1119:3: ( rule__InstancePropertyRef__PropertyAssignment_1_1_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefAccess().getPropertyAssignment_1_1_1());
|
|
}
|
|
// InternalRDL.g:1120:3: ( rule__InstancePropertyRef__PropertyAssignment_1_1_1 )
|
|
// InternalRDL.g:1120:4: rule__InstancePropertyRef__PropertyAssignment_1_1_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstancePropertyRef__PropertyAssignment_1_1_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefAccess().getPropertyAssignment_1_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstancePropertyRef__Alternatives_1_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__Alternatives"
|
|
// InternalRDL.g:1128:1: rule__PropertyAssignmentRhs__Alternatives : ( ( ( rule__PropertyAssignmentRhs__ValueAssignment_0 ) ) | ( ( rule__PropertyAssignmentRhs__InstPropRefAssignment_1 ) ) | ( ( rule__PropertyAssignmentRhs__Group_2__0 ) ) | ( ( rule__PropertyAssignmentRhs__ElementsAssignment_3 ) ) );
|
|
public final void rule__PropertyAssignmentRhs__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1132:1: ( ( ( rule__PropertyAssignmentRhs__ValueAssignment_0 ) ) | ( ( rule__PropertyAssignmentRhs__InstPropRefAssignment_1 ) ) | ( ( rule__PropertyAssignmentRhs__Group_2__0 ) ) | ( ( rule__PropertyAssignmentRhs__ElementsAssignment_3 ) ) )
|
|
int alt16=4;
|
|
switch ( input.LA(1) ) {
|
|
case RULE_STR:
|
|
case RULE_NUM:
|
|
case 82:
|
|
case 83:
|
|
case 97:
|
|
case 98:
|
|
case 99:
|
|
case 100:
|
|
case 101:
|
|
case 102:
|
|
case 103:
|
|
case 104:
|
|
case 105:
|
|
case 106:
|
|
case 107:
|
|
{
|
|
alt16=1;
|
|
}
|
|
break;
|
|
case RULE_ID:
|
|
{
|
|
int LA16_2 = input.LA(2);
|
|
|
|
if ( (LA16_2==EOF||LA16_2==113||(LA16_2>=131 && LA16_2<=132)) ) {
|
|
alt16=2;
|
|
}
|
|
else if ( (LA16_2==133) ) {
|
|
alt16=3;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 16, 2, input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
break;
|
|
case 116:
|
|
{
|
|
alt16=4;
|
|
}
|
|
break;
|
|
default:
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 16, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt16) {
|
|
case 1 :
|
|
// InternalRDL.g:1133:2: ( ( rule__PropertyAssignmentRhs__ValueAssignment_0 ) )
|
|
{
|
|
// InternalRDL.g:1133:2: ( ( rule__PropertyAssignmentRhs__ValueAssignment_0 ) )
|
|
// InternalRDL.g:1134:3: ( rule__PropertyAssignmentRhs__ValueAssignment_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getValueAssignment_0());
|
|
}
|
|
// InternalRDL.g:1135:3: ( rule__PropertyAssignmentRhs__ValueAssignment_0 )
|
|
// InternalRDL.g:1135:4: rule__PropertyAssignmentRhs__ValueAssignment_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyAssignmentRhs__ValueAssignment_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getValueAssignment_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1139:2: ( ( rule__PropertyAssignmentRhs__InstPropRefAssignment_1 ) )
|
|
{
|
|
// InternalRDL.g:1139:2: ( ( rule__PropertyAssignmentRhs__InstPropRefAssignment_1 ) )
|
|
// InternalRDL.g:1140:3: ( rule__PropertyAssignmentRhs__InstPropRefAssignment_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getInstPropRefAssignment_1());
|
|
}
|
|
// InternalRDL.g:1141:3: ( rule__PropertyAssignmentRhs__InstPropRefAssignment_1 )
|
|
// InternalRDL.g:1141:4: rule__PropertyAssignmentRhs__InstPropRefAssignment_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyAssignmentRhs__InstPropRefAssignment_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getInstPropRefAssignment_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:1145:2: ( ( rule__PropertyAssignmentRhs__Group_2__0 ) )
|
|
{
|
|
// InternalRDL.g:1145:2: ( ( rule__PropertyAssignmentRhs__Group_2__0 ) )
|
|
// InternalRDL.g:1146:3: ( rule__PropertyAssignmentRhs__Group_2__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getGroup_2());
|
|
}
|
|
// InternalRDL.g:1147:3: ( rule__PropertyAssignmentRhs__Group_2__0 )
|
|
// InternalRDL.g:1147:4: rule__PropertyAssignmentRhs__Group_2__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyAssignmentRhs__Group_2__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getGroup_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:1151:2: ( ( rule__PropertyAssignmentRhs__ElementsAssignment_3 ) )
|
|
{
|
|
// InternalRDL.g:1151:2: ( ( rule__PropertyAssignmentRhs__ElementsAssignment_3 ) )
|
|
// InternalRDL.g:1152:3: ( rule__PropertyAssignmentRhs__ElementsAssignment_3 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getElementsAssignment_3());
|
|
}
|
|
// InternalRDL.g:1153:3: ( rule__PropertyAssignmentRhs__ElementsAssignment_3 )
|
|
// InternalRDL.g:1153:4: rule__PropertyAssignmentRhs__ElementsAssignment_3
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyAssignmentRhs__ElementsAssignment_3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getElementsAssignment_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__ConcatElem__Alternatives"
|
|
// InternalRDL.g:1161:1: rule__ConcatElem__Alternatives : ( ( ( rule__ConcatElem__InstPropRefAssignment_0 ) ) | ( ( rule__ConcatElem__ValueAssignment_1 ) ) );
|
|
public final void rule__ConcatElem__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1165:1: ( ( ( rule__ConcatElem__InstPropRefAssignment_0 ) ) | ( ( rule__ConcatElem__ValueAssignment_1 ) ) )
|
|
int alt17=2;
|
|
int LA17_0 = input.LA(1);
|
|
|
|
if ( (LA17_0==RULE_ID) ) {
|
|
alt17=1;
|
|
}
|
|
else if ( (LA17_0==RULE_NUM) ) {
|
|
alt17=2;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 17, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt17) {
|
|
case 1 :
|
|
// InternalRDL.g:1166:2: ( ( rule__ConcatElem__InstPropRefAssignment_0 ) )
|
|
{
|
|
// InternalRDL.g:1166:2: ( ( rule__ConcatElem__InstPropRefAssignment_0 ) )
|
|
// InternalRDL.g:1167:3: ( rule__ConcatElem__InstPropRefAssignment_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatElemAccess().getInstPropRefAssignment_0());
|
|
}
|
|
// InternalRDL.g:1168:3: ( rule__ConcatElem__InstPropRefAssignment_0 )
|
|
// InternalRDL.g:1168:4: rule__ConcatElem__InstPropRefAssignment_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ConcatElem__InstPropRefAssignment_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatElemAccess().getInstPropRefAssignment_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1172:2: ( ( rule__ConcatElem__ValueAssignment_1 ) )
|
|
{
|
|
// InternalRDL.g:1172:2: ( ( rule__ConcatElem__ValueAssignment_1 ) )
|
|
// InternalRDL.g:1173:3: ( rule__ConcatElem__ValueAssignment_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatElemAccess().getValueAssignment_1());
|
|
}
|
|
// InternalRDL.g:1174:3: ( rule__ConcatElem__ValueAssignment_1 )
|
|
// InternalRDL.g:1174:4: rule__ConcatElem__ValueAssignment_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ConcatElem__ValueAssignment_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatElemAccess().getValueAssignment_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ConcatElem__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyRvalueConstant__Alternatives"
|
|
// InternalRDL.g:1182:1: rule__PropertyRvalueConstant__Alternatives : ( ( ( rule__PropertyRvalueConstant__ValAssignment_0 ) ) | ( ( rule__PropertyRvalueConstant__NumAssignment_1 ) ) | ( ( rule__PropertyRvalueConstant__StrAssignment_2 ) ) );
|
|
public final void rule__PropertyRvalueConstant__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1186:1: ( ( ( rule__PropertyRvalueConstant__ValAssignment_0 ) ) | ( ( rule__PropertyRvalueConstant__NumAssignment_1 ) ) | ( ( rule__PropertyRvalueConstant__StrAssignment_2 ) ) )
|
|
int alt18=3;
|
|
switch ( input.LA(1) ) {
|
|
case 82:
|
|
case 83:
|
|
case 97:
|
|
case 98:
|
|
case 99:
|
|
case 100:
|
|
case 101:
|
|
case 102:
|
|
case 103:
|
|
case 104:
|
|
case 105:
|
|
case 106:
|
|
case 107:
|
|
{
|
|
alt18=1;
|
|
}
|
|
break;
|
|
case RULE_NUM:
|
|
{
|
|
alt18=2;
|
|
}
|
|
break;
|
|
case RULE_STR:
|
|
{
|
|
alt18=3;
|
|
}
|
|
break;
|
|
default:
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 18, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt18) {
|
|
case 1 :
|
|
// InternalRDL.g:1187:2: ( ( rule__PropertyRvalueConstant__ValAssignment_0 ) )
|
|
{
|
|
// InternalRDL.g:1187:2: ( ( rule__PropertyRvalueConstant__ValAssignment_0 ) )
|
|
// InternalRDL.g:1188:3: ( rule__PropertyRvalueConstant__ValAssignment_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyRvalueConstantAccess().getValAssignment_0());
|
|
}
|
|
// InternalRDL.g:1189:3: ( rule__PropertyRvalueConstant__ValAssignment_0 )
|
|
// InternalRDL.g:1189:4: rule__PropertyRvalueConstant__ValAssignment_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyRvalueConstant__ValAssignment_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyRvalueConstantAccess().getValAssignment_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1193:2: ( ( rule__PropertyRvalueConstant__NumAssignment_1 ) )
|
|
{
|
|
// InternalRDL.g:1193:2: ( ( rule__PropertyRvalueConstant__NumAssignment_1 ) )
|
|
// InternalRDL.g:1194:3: ( rule__PropertyRvalueConstant__NumAssignment_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyRvalueConstantAccess().getNumAssignment_1());
|
|
}
|
|
// InternalRDL.g:1195:3: ( rule__PropertyRvalueConstant__NumAssignment_1 )
|
|
// InternalRDL.g:1195:4: rule__PropertyRvalueConstant__NumAssignment_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyRvalueConstant__NumAssignment_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyRvalueConstantAccess().getNumAssignment_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:1199:2: ( ( rule__PropertyRvalueConstant__StrAssignment_2 ) )
|
|
{
|
|
// InternalRDL.g:1199:2: ( ( rule__PropertyRvalueConstant__StrAssignment_2 ) )
|
|
// InternalRDL.g:1200:3: ( rule__PropertyRvalueConstant__StrAssignment_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyRvalueConstantAccess().getStrAssignment_2());
|
|
}
|
|
// InternalRDL.g:1201:3: ( rule__PropertyRvalueConstant__StrAssignment_2 )
|
|
// InternalRDL.g:1201:4: rule__PropertyRvalueConstant__StrAssignment_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyRvalueConstant__StrAssignment_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyRvalueConstantAccess().getStrAssignment_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyRvalueConstant__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Alternatives_0"
|
|
// InternalRDL.g:1209:1: rule__EnumProperty__Alternatives_0 : ( ( ( rule__EnumProperty__Group_0_0__0 ) ) | ( ( rule__EnumProperty__Group_0_1__0 ) ) );
|
|
public final void rule__EnumProperty__Alternatives_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1213:1: ( ( ( rule__EnumProperty__Group_0_0__0 ) ) | ( ( rule__EnumProperty__Group_0_1__0 ) ) )
|
|
int alt19=2;
|
|
int LA19_0 = input.LA(1);
|
|
|
|
if ( (LA19_0==22) ) {
|
|
alt19=1;
|
|
}
|
|
else if ( (LA19_0==23) ) {
|
|
alt19=2;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 19, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt19) {
|
|
case 1 :
|
|
// InternalRDL.g:1214:2: ( ( rule__EnumProperty__Group_0_0__0 ) )
|
|
{
|
|
// InternalRDL.g:1214:2: ( ( rule__EnumProperty__Group_0_0__0 ) )
|
|
// InternalRDL.g:1215:3: ( rule__EnumProperty__Group_0_0__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getGroup_0_0());
|
|
}
|
|
// InternalRDL.g:1216:3: ( rule__EnumProperty__Group_0_0__0 )
|
|
// InternalRDL.g:1216:4: rule__EnumProperty__Group_0_0__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__Group_0_0__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getGroup_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1220:2: ( ( rule__EnumProperty__Group_0_1__0 ) )
|
|
{
|
|
// InternalRDL.g:1220:2: ( ( rule__EnumProperty__Group_0_1__0 ) )
|
|
// InternalRDL.g:1221:3: ( rule__EnumProperty__Group_0_1__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getGroup_0_1());
|
|
}
|
|
// InternalRDL.g:1222:3: ( rule__EnumProperty__Group_0_1__0 )
|
|
// InternalRDL.g:1222:4: rule__EnumProperty__Group_0_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__Group_0_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getGroup_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Alternatives_0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumInstanceType__Alternatives"
|
|
// InternalRDL.g:1230:1: rule__EnumInstanceType__Alternatives : ( ( ( rule__EnumInstanceType__EXTERNALAssignment_0 ) ) | ( ( rule__EnumInstanceType__INTERNALAssignment_1 ) ) );
|
|
public final void rule__EnumInstanceType__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1234:1: ( ( ( rule__EnumInstanceType__EXTERNALAssignment_0 ) ) | ( ( rule__EnumInstanceType__INTERNALAssignment_1 ) ) )
|
|
int alt20=2;
|
|
int LA20_0 = input.LA(1);
|
|
|
|
if ( (LA20_0==134) ) {
|
|
alt20=1;
|
|
}
|
|
else if ( (LA20_0==76) ) {
|
|
alt20=2;
|
|
}
|
|
else {
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 20, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt20) {
|
|
case 1 :
|
|
// InternalRDL.g:1235:2: ( ( rule__EnumInstanceType__EXTERNALAssignment_0 ) )
|
|
{
|
|
// InternalRDL.g:1235:2: ( ( rule__EnumInstanceType__EXTERNALAssignment_0 ) )
|
|
// InternalRDL.g:1236:3: ( rule__EnumInstanceType__EXTERNALAssignment_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumInstanceTypeAccess().getEXTERNALAssignment_0());
|
|
}
|
|
// InternalRDL.g:1237:3: ( rule__EnumInstanceType__EXTERNALAssignment_0 )
|
|
// InternalRDL.g:1237:4: rule__EnumInstanceType__EXTERNALAssignment_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumInstanceType__EXTERNALAssignment_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumInstanceTypeAccess().getEXTERNALAssignment_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1241:2: ( ( rule__EnumInstanceType__INTERNALAssignment_1 ) )
|
|
{
|
|
// InternalRDL.g:1241:2: ( ( rule__EnumInstanceType__INTERNALAssignment_1 ) )
|
|
// InternalRDL.g:1242:3: ( rule__EnumInstanceType__INTERNALAssignment_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumInstanceTypeAccess().getINTERNALAssignment_1());
|
|
}
|
|
// InternalRDL.g:1243:3: ( rule__EnumInstanceType__INTERNALAssignment_1 )
|
|
// InternalRDL.g:1243:4: rule__EnumInstanceType__INTERNALAssignment_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumInstanceType__INTERNALAssignment_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumInstanceTypeAccess().getINTERNALAssignment_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumInstanceType__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyTypeName__Alternatives"
|
|
// InternalRDL.g:1251:1: rule__PropertyTypeName__Alternatives : ( ( ( 'string' ) ) | ( ( 'number' ) ) | ( ( 'boolean' ) ) | ( ( 'addrmap' ) ) | ( ( 'reg' ) ) | ( ( 'regfile' ) ) | ( ( 'field' ) ) | ( ( 'ref' ) ) );
|
|
public final void rule__PropertyTypeName__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1255:1: ( ( ( 'string' ) ) | ( ( 'number' ) ) | ( ( 'boolean' ) ) | ( ( 'addrmap' ) ) | ( ( 'reg' ) ) | ( ( 'regfile' ) ) | ( ( 'field' ) ) | ( ( 'ref' ) ) )
|
|
int alt21=8;
|
|
switch ( input.LA(1) ) {
|
|
case 12:
|
|
{
|
|
alt21=1;
|
|
}
|
|
break;
|
|
case 13:
|
|
{
|
|
alt21=2;
|
|
}
|
|
break;
|
|
case 14:
|
|
{
|
|
alt21=3;
|
|
}
|
|
break;
|
|
case 15:
|
|
{
|
|
alt21=4;
|
|
}
|
|
break;
|
|
case 16:
|
|
{
|
|
alt21=5;
|
|
}
|
|
break;
|
|
case 17:
|
|
{
|
|
alt21=6;
|
|
}
|
|
break;
|
|
case 18:
|
|
{
|
|
alt21=7;
|
|
}
|
|
break;
|
|
case 19:
|
|
{
|
|
alt21=8;
|
|
}
|
|
break;
|
|
default:
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 21, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt21) {
|
|
case 1 :
|
|
// InternalRDL.g:1256:2: ( ( 'string' ) )
|
|
{
|
|
// InternalRDL.g:1256:2: ( ( 'string' ) )
|
|
// InternalRDL.g:1257:3: ( 'string' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyTypeNameAccess().getSTRINGEnumLiteralDeclaration_0());
|
|
}
|
|
// InternalRDL.g:1258:3: ( 'string' )
|
|
// InternalRDL.g:1258:4: 'string'
|
|
{
|
|
match(input,12,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyTypeNameAccess().getSTRINGEnumLiteralDeclaration_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1262:2: ( ( 'number' ) )
|
|
{
|
|
// InternalRDL.g:1262:2: ( ( 'number' ) )
|
|
// InternalRDL.g:1263:3: ( 'number' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyTypeNameAccess().getNUMBEREnumLiteralDeclaration_1());
|
|
}
|
|
// InternalRDL.g:1264:3: ( 'number' )
|
|
// InternalRDL.g:1264:4: 'number'
|
|
{
|
|
match(input,13,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyTypeNameAccess().getNUMBEREnumLiteralDeclaration_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:1268:2: ( ( 'boolean' ) )
|
|
{
|
|
// InternalRDL.g:1268:2: ( ( 'boolean' ) )
|
|
// InternalRDL.g:1269:3: ( 'boolean' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyTypeNameAccess().getBOOLEANEnumLiteralDeclaration_2());
|
|
}
|
|
// InternalRDL.g:1270:3: ( 'boolean' )
|
|
// InternalRDL.g:1270:4: 'boolean'
|
|
{
|
|
match(input,14,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyTypeNameAccess().getBOOLEANEnumLiteralDeclaration_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:1274:2: ( ( 'addrmap' ) )
|
|
{
|
|
// InternalRDL.g:1274:2: ( ( 'addrmap' ) )
|
|
// InternalRDL.g:1275:3: ( 'addrmap' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyTypeNameAccess().getADDRMAPEnumLiteralDeclaration_3());
|
|
}
|
|
// InternalRDL.g:1276:3: ( 'addrmap' )
|
|
// InternalRDL.g:1276:4: 'addrmap'
|
|
{
|
|
match(input,15,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyTypeNameAccess().getADDRMAPEnumLiteralDeclaration_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 5 :
|
|
// InternalRDL.g:1280:2: ( ( 'reg' ) )
|
|
{
|
|
// InternalRDL.g:1280:2: ( ( 'reg' ) )
|
|
// InternalRDL.g:1281:3: ( 'reg' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyTypeNameAccess().getREGEnumLiteralDeclaration_4());
|
|
}
|
|
// InternalRDL.g:1282:3: ( 'reg' )
|
|
// InternalRDL.g:1282:4: 'reg'
|
|
{
|
|
match(input,16,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyTypeNameAccess().getREGEnumLiteralDeclaration_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 6 :
|
|
// InternalRDL.g:1286:2: ( ( 'regfile' ) )
|
|
{
|
|
// InternalRDL.g:1286:2: ( ( 'regfile' ) )
|
|
// InternalRDL.g:1287:3: ( 'regfile' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyTypeNameAccess().getREGFILEEnumLiteralDeclaration_5());
|
|
}
|
|
// InternalRDL.g:1288:3: ( 'regfile' )
|
|
// InternalRDL.g:1288:4: 'regfile'
|
|
{
|
|
match(input,17,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyTypeNameAccess().getREGFILEEnumLiteralDeclaration_5());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 7 :
|
|
// InternalRDL.g:1292:2: ( ( 'field' ) )
|
|
{
|
|
// InternalRDL.g:1292:2: ( ( 'field' ) )
|
|
// InternalRDL.g:1293:3: ( 'field' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyTypeNameAccess().getFIELDEnumLiteralDeclaration_6());
|
|
}
|
|
// InternalRDL.g:1294:3: ( 'field' )
|
|
// InternalRDL.g:1294:4: 'field'
|
|
{
|
|
match(input,18,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyTypeNameAccess().getFIELDEnumLiteralDeclaration_6());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 8 :
|
|
// InternalRDL.g:1298:2: ( ( 'ref' ) )
|
|
{
|
|
// InternalRDL.g:1298:2: ( ( 'ref' ) )
|
|
// InternalRDL.g:1299:3: ( 'ref' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyTypeNameAccess().getREFEnumLiteralDeclaration_7());
|
|
}
|
|
// InternalRDL.g:1300:3: ( 'ref' )
|
|
// InternalRDL.g:1300:4: 'ref'
|
|
{
|
|
match(input,19,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyTypeNameAccess().getREFEnumLiteralDeclaration_7());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyTypeName__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyComponent__Alternatives"
|
|
// InternalRDL.g:1308:1: rule__PropertyComponent__Alternatives : ( ( ( 'signal' ) ) | ( ( 'addrmap' ) ) | ( ( 'reg' ) ) | ( ( 'regfile' ) ) | ( ( 'field' ) ) | ( ( 'all' ) ) );
|
|
public final void rule__PropertyComponent__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1312:1: ( ( ( 'signal' ) ) | ( ( 'addrmap' ) ) | ( ( 'reg' ) ) | ( ( 'regfile' ) ) | ( ( 'field' ) ) | ( ( 'all' ) ) )
|
|
int alt22=6;
|
|
switch ( input.LA(1) ) {
|
|
case 20:
|
|
{
|
|
alt22=1;
|
|
}
|
|
break;
|
|
case 15:
|
|
{
|
|
alt22=2;
|
|
}
|
|
break;
|
|
case 16:
|
|
{
|
|
alt22=3;
|
|
}
|
|
break;
|
|
case 17:
|
|
{
|
|
alt22=4;
|
|
}
|
|
break;
|
|
case 18:
|
|
{
|
|
alt22=5;
|
|
}
|
|
break;
|
|
case 21:
|
|
{
|
|
alt22=6;
|
|
}
|
|
break;
|
|
default:
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 22, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt22) {
|
|
case 1 :
|
|
// InternalRDL.g:1313:2: ( ( 'signal' ) )
|
|
{
|
|
// InternalRDL.g:1313:2: ( ( 'signal' ) )
|
|
// InternalRDL.g:1314:3: ( 'signal' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyComponentAccess().getSIGNALEnumLiteralDeclaration_0());
|
|
}
|
|
// InternalRDL.g:1315:3: ( 'signal' )
|
|
// InternalRDL.g:1315:4: 'signal'
|
|
{
|
|
match(input,20,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyComponentAccess().getSIGNALEnumLiteralDeclaration_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1319:2: ( ( 'addrmap' ) )
|
|
{
|
|
// InternalRDL.g:1319:2: ( ( 'addrmap' ) )
|
|
// InternalRDL.g:1320:3: ( 'addrmap' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyComponentAccess().getADDRMAPEnumLiteralDeclaration_1());
|
|
}
|
|
// InternalRDL.g:1321:3: ( 'addrmap' )
|
|
// InternalRDL.g:1321:4: 'addrmap'
|
|
{
|
|
match(input,15,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyComponentAccess().getADDRMAPEnumLiteralDeclaration_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:1325:2: ( ( 'reg' ) )
|
|
{
|
|
// InternalRDL.g:1325:2: ( ( 'reg' ) )
|
|
// InternalRDL.g:1326:3: ( 'reg' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyComponentAccess().getREGEnumLiteralDeclaration_2());
|
|
}
|
|
// InternalRDL.g:1327:3: ( 'reg' )
|
|
// InternalRDL.g:1327:4: 'reg'
|
|
{
|
|
match(input,16,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyComponentAccess().getREGEnumLiteralDeclaration_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:1331:2: ( ( 'regfile' ) )
|
|
{
|
|
// InternalRDL.g:1331:2: ( ( 'regfile' ) )
|
|
// InternalRDL.g:1332:3: ( 'regfile' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyComponentAccess().getREGFILEEnumLiteralDeclaration_3());
|
|
}
|
|
// InternalRDL.g:1333:3: ( 'regfile' )
|
|
// InternalRDL.g:1333:4: 'regfile'
|
|
{
|
|
match(input,17,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyComponentAccess().getREGFILEEnumLiteralDeclaration_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 5 :
|
|
// InternalRDL.g:1337:2: ( ( 'field' ) )
|
|
{
|
|
// InternalRDL.g:1337:2: ( ( 'field' ) )
|
|
// InternalRDL.g:1338:3: ( 'field' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyComponentAccess().getFIELDEnumLiteralDeclaration_4());
|
|
}
|
|
// InternalRDL.g:1339:3: ( 'field' )
|
|
// InternalRDL.g:1339:4: 'field'
|
|
{
|
|
match(input,18,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyComponentAccess().getFIELDEnumLiteralDeclaration_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 6 :
|
|
// InternalRDL.g:1343:2: ( ( 'all' ) )
|
|
{
|
|
// InternalRDL.g:1343:2: ( ( 'all' ) )
|
|
// InternalRDL.g:1344:3: ( 'all' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyComponentAccess().getALLEnumLiteralDeclaration_5());
|
|
}
|
|
// InternalRDL.g:1345:3: ( 'all' )
|
|
// InternalRDL.g:1345:4: 'all'
|
|
{
|
|
match(input,21,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyComponentAccess().getALLEnumLiteralDeclaration_5());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyComponent__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinitionType__Alternatives"
|
|
// InternalRDL.g:1353:1: rule__ComponentDefinitionType__Alternatives : ( ( ( 'signal' ) ) | ( ( 'addrmap' ) ) | ( ( 'regfile' ) ) | ( ( 'reg' ) ) | ( ( 'field' ) ) );
|
|
public final void rule__ComponentDefinitionType__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1357:1: ( ( ( 'signal' ) ) | ( ( 'addrmap' ) ) | ( ( 'regfile' ) ) | ( ( 'reg' ) ) | ( ( 'field' ) ) )
|
|
int alt23=5;
|
|
switch ( input.LA(1) ) {
|
|
case 20:
|
|
{
|
|
alt23=1;
|
|
}
|
|
break;
|
|
case 15:
|
|
{
|
|
alt23=2;
|
|
}
|
|
break;
|
|
case 17:
|
|
{
|
|
alt23=3;
|
|
}
|
|
break;
|
|
case 16:
|
|
{
|
|
alt23=4;
|
|
}
|
|
break;
|
|
case 18:
|
|
{
|
|
alt23=5;
|
|
}
|
|
break;
|
|
default:
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 23, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt23) {
|
|
case 1 :
|
|
// InternalRDL.g:1358:2: ( ( 'signal' ) )
|
|
{
|
|
// InternalRDL.g:1358:2: ( ( 'signal' ) )
|
|
// InternalRDL.g:1359:3: ( 'signal' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionTypeAccess().getSIGNALEnumLiteralDeclaration_0());
|
|
}
|
|
// InternalRDL.g:1360:3: ( 'signal' )
|
|
// InternalRDL.g:1360:4: 'signal'
|
|
{
|
|
match(input,20,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionTypeAccess().getSIGNALEnumLiteralDeclaration_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1364:2: ( ( 'addrmap' ) )
|
|
{
|
|
// InternalRDL.g:1364:2: ( ( 'addrmap' ) )
|
|
// InternalRDL.g:1365:3: ( 'addrmap' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionTypeAccess().getADDRMAPEnumLiteralDeclaration_1());
|
|
}
|
|
// InternalRDL.g:1366:3: ( 'addrmap' )
|
|
// InternalRDL.g:1366:4: 'addrmap'
|
|
{
|
|
match(input,15,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionTypeAccess().getADDRMAPEnumLiteralDeclaration_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:1370:2: ( ( 'regfile' ) )
|
|
{
|
|
// InternalRDL.g:1370:2: ( ( 'regfile' ) )
|
|
// InternalRDL.g:1371:3: ( 'regfile' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionTypeAccess().getREGFILEEnumLiteralDeclaration_2());
|
|
}
|
|
// InternalRDL.g:1372:3: ( 'regfile' )
|
|
// InternalRDL.g:1372:4: 'regfile'
|
|
{
|
|
match(input,17,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionTypeAccess().getREGFILEEnumLiteralDeclaration_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:1376:2: ( ( 'reg' ) )
|
|
{
|
|
// InternalRDL.g:1376:2: ( ( 'reg' ) )
|
|
// InternalRDL.g:1377:3: ( 'reg' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionTypeAccess().getREGEnumLiteralDeclaration_3());
|
|
}
|
|
// InternalRDL.g:1378:3: ( 'reg' )
|
|
// InternalRDL.g:1378:4: 'reg'
|
|
{
|
|
match(input,16,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionTypeAccess().getREGEnumLiteralDeclaration_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 5 :
|
|
// InternalRDL.g:1382:2: ( ( 'field' ) )
|
|
{
|
|
// InternalRDL.g:1382:2: ( ( 'field' ) )
|
|
// InternalRDL.g:1383:3: ( 'field' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionTypeAccess().getFIELDEnumLiteralDeclaration_4());
|
|
}
|
|
// InternalRDL.g:1384:3: ( 'field' )
|
|
// InternalRDL.g:1384:4: 'field'
|
|
{
|
|
match(input,18,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionTypeAccess().getFIELDEnumLiteralDeclaration_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinitionType__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__Property__Alternatives"
|
|
// InternalRDL.g:1392:1: rule__Property__Alternatives : ( ( ( 'name' ) ) | ( ( 'desc' ) ) | ( ( 'arbiter' ) ) | ( ( 'rset' ) ) | ( ( 'rclr' ) ) | ( ( 'woclr' ) ) | ( ( 'woset' ) ) | ( ( 'we' ) ) | ( ( 'wel' ) ) | ( ( 'swwe' ) ) | ( ( 'swwel' ) ) | ( ( 'hwset' ) ) | ( ( 'hwclr' ) ) | ( ( 'swmod' ) ) | ( ( 'swacc' ) ) | ( ( 'sticky' ) ) | ( ( 'stickybit' ) ) | ( ( 'intr' ) ) | ( ( 'anded' ) ) | ( ( 'ored' ) ) | ( ( 'xored' ) ) | ( ( 'counter' ) ) | ( ( 'overflow' ) ) | ( ( 'sharedextbus' ) ) | ( ( 'errextbus' ) ) | ( ( 'reset' ) ) | ( ( 'littleendian' ) ) | ( ( 'bigendian' ) ) | ( ( 'rsvdset' ) ) | ( ( 'rsvdsetX' ) ) | ( ( 'bridge' ) ) | ( ( 'shared' ) ) | ( ( 'msb0' ) ) | ( ( 'lsb0' ) ) | ( ( 'sync' ) ) | ( ( 'async' ) ) | ( ( 'cpuif_reset' ) ) | ( ( 'field_reset' ) ) | ( ( 'activehigh' ) ) | ( ( 'activelow' ) ) | ( ( 'singlepulse' ) ) | ( ( 'underflow' ) ) | ( ( 'incr' ) ) | ( ( 'decr' ) ) | ( ( 'incrwidth' ) ) | ( ( 'decrwidth' ) ) | ( ( 'incrvalue' ) ) | ( ( 'decrvalue' ) ) | ( ( 'saturate' ) ) | ( ( 'decrsaturate' ) ) | ( ( 'threshold' ) ) | ( ( 'decrthreshold' ) ) | ( ( 'dontcompare' ) ) | ( ( 'donttest' ) ) | ( ( 'internal' ) ) | ( ( 'alignment' ) ) | ( ( 'regwidth' ) ) | ( ( 'fieldwidth' ) ) | ( ( 'signalwidth' ) ) | ( ( 'accesswidth' ) ) | ( ( 'sw' ) ) | ( ( 'hw' ) ) | ( ( 'addressing' ) ) | ( ( 'precedence' ) ) | ( ( 'encode' ) ) | ( ( 'resetsignal' ) ) | ( ( 'clock' ) ) | ( ( 'mask' ) ) | ( ( 'enable' ) ) | ( ( 'hwenable' ) ) | ( ( 'hwmask' ) ) | ( ( 'haltmask' ) ) | ( ( 'haltenable' ) ) | ( ( 'halt' ) ) | ( ( 'next' ) ) );
|
|
public final void rule__Property__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1396:1: ( ( ( 'name' ) ) | ( ( 'desc' ) ) | ( ( 'arbiter' ) ) | ( ( 'rset' ) ) | ( ( 'rclr' ) ) | ( ( 'woclr' ) ) | ( ( 'woset' ) ) | ( ( 'we' ) ) | ( ( 'wel' ) ) | ( ( 'swwe' ) ) | ( ( 'swwel' ) ) | ( ( 'hwset' ) ) | ( ( 'hwclr' ) ) | ( ( 'swmod' ) ) | ( ( 'swacc' ) ) | ( ( 'sticky' ) ) | ( ( 'stickybit' ) ) | ( ( 'intr' ) ) | ( ( 'anded' ) ) | ( ( 'ored' ) ) | ( ( 'xored' ) ) | ( ( 'counter' ) ) | ( ( 'overflow' ) ) | ( ( 'sharedextbus' ) ) | ( ( 'errextbus' ) ) | ( ( 'reset' ) ) | ( ( 'littleendian' ) ) | ( ( 'bigendian' ) ) | ( ( 'rsvdset' ) ) | ( ( 'rsvdsetX' ) ) | ( ( 'bridge' ) ) | ( ( 'shared' ) ) | ( ( 'msb0' ) ) | ( ( 'lsb0' ) ) | ( ( 'sync' ) ) | ( ( 'async' ) ) | ( ( 'cpuif_reset' ) ) | ( ( 'field_reset' ) ) | ( ( 'activehigh' ) ) | ( ( 'activelow' ) ) | ( ( 'singlepulse' ) ) | ( ( 'underflow' ) ) | ( ( 'incr' ) ) | ( ( 'decr' ) ) | ( ( 'incrwidth' ) ) | ( ( 'decrwidth' ) ) | ( ( 'incrvalue' ) ) | ( ( 'decrvalue' ) ) | ( ( 'saturate' ) ) | ( ( 'decrsaturate' ) ) | ( ( 'threshold' ) ) | ( ( 'decrthreshold' ) ) | ( ( 'dontcompare' ) ) | ( ( 'donttest' ) ) | ( ( 'internal' ) ) | ( ( 'alignment' ) ) | ( ( 'regwidth' ) ) | ( ( 'fieldwidth' ) ) | ( ( 'signalwidth' ) ) | ( ( 'accesswidth' ) ) | ( ( 'sw' ) ) | ( ( 'hw' ) ) | ( ( 'addressing' ) ) | ( ( 'precedence' ) ) | ( ( 'encode' ) ) | ( ( 'resetsignal' ) ) | ( ( 'clock' ) ) | ( ( 'mask' ) ) | ( ( 'enable' ) ) | ( ( 'hwenable' ) ) | ( ( 'hwmask' ) ) | ( ( 'haltmask' ) ) | ( ( 'haltenable' ) ) | ( ( 'halt' ) ) | ( ( 'next' ) ) )
|
|
int alt24=75;
|
|
switch ( input.LA(1) ) {
|
|
case 22:
|
|
{
|
|
alt24=1;
|
|
}
|
|
break;
|
|
case 23:
|
|
{
|
|
alt24=2;
|
|
}
|
|
break;
|
|
case 24:
|
|
{
|
|
alt24=3;
|
|
}
|
|
break;
|
|
case 25:
|
|
{
|
|
alt24=4;
|
|
}
|
|
break;
|
|
case 26:
|
|
{
|
|
alt24=5;
|
|
}
|
|
break;
|
|
case 27:
|
|
{
|
|
alt24=6;
|
|
}
|
|
break;
|
|
case 28:
|
|
{
|
|
alt24=7;
|
|
}
|
|
break;
|
|
case 29:
|
|
{
|
|
alt24=8;
|
|
}
|
|
break;
|
|
case 30:
|
|
{
|
|
alt24=9;
|
|
}
|
|
break;
|
|
case 31:
|
|
{
|
|
alt24=10;
|
|
}
|
|
break;
|
|
case 32:
|
|
{
|
|
alt24=11;
|
|
}
|
|
break;
|
|
case 33:
|
|
{
|
|
alt24=12;
|
|
}
|
|
break;
|
|
case 34:
|
|
{
|
|
alt24=13;
|
|
}
|
|
break;
|
|
case 35:
|
|
{
|
|
alt24=14;
|
|
}
|
|
break;
|
|
case 36:
|
|
{
|
|
alt24=15;
|
|
}
|
|
break;
|
|
case 37:
|
|
{
|
|
alt24=16;
|
|
}
|
|
break;
|
|
case 38:
|
|
{
|
|
alt24=17;
|
|
}
|
|
break;
|
|
case 39:
|
|
{
|
|
alt24=18;
|
|
}
|
|
break;
|
|
case 40:
|
|
{
|
|
alt24=19;
|
|
}
|
|
break;
|
|
case 41:
|
|
{
|
|
alt24=20;
|
|
}
|
|
break;
|
|
case 42:
|
|
{
|
|
alt24=21;
|
|
}
|
|
break;
|
|
case 43:
|
|
{
|
|
alt24=22;
|
|
}
|
|
break;
|
|
case 44:
|
|
{
|
|
alt24=23;
|
|
}
|
|
break;
|
|
case 45:
|
|
{
|
|
alt24=24;
|
|
}
|
|
break;
|
|
case 46:
|
|
{
|
|
alt24=25;
|
|
}
|
|
break;
|
|
case 47:
|
|
{
|
|
alt24=26;
|
|
}
|
|
break;
|
|
case 48:
|
|
{
|
|
alt24=27;
|
|
}
|
|
break;
|
|
case 49:
|
|
{
|
|
alt24=28;
|
|
}
|
|
break;
|
|
case 50:
|
|
{
|
|
alt24=29;
|
|
}
|
|
break;
|
|
case 51:
|
|
{
|
|
alt24=30;
|
|
}
|
|
break;
|
|
case 52:
|
|
{
|
|
alt24=31;
|
|
}
|
|
break;
|
|
case 53:
|
|
{
|
|
alt24=32;
|
|
}
|
|
break;
|
|
case 54:
|
|
{
|
|
alt24=33;
|
|
}
|
|
break;
|
|
case 55:
|
|
{
|
|
alt24=34;
|
|
}
|
|
break;
|
|
case 56:
|
|
{
|
|
alt24=35;
|
|
}
|
|
break;
|
|
case 57:
|
|
{
|
|
alt24=36;
|
|
}
|
|
break;
|
|
case 58:
|
|
{
|
|
alt24=37;
|
|
}
|
|
break;
|
|
case 59:
|
|
{
|
|
alt24=38;
|
|
}
|
|
break;
|
|
case 60:
|
|
{
|
|
alt24=39;
|
|
}
|
|
break;
|
|
case 61:
|
|
{
|
|
alt24=40;
|
|
}
|
|
break;
|
|
case 62:
|
|
{
|
|
alt24=41;
|
|
}
|
|
break;
|
|
case 63:
|
|
{
|
|
alt24=42;
|
|
}
|
|
break;
|
|
case 64:
|
|
{
|
|
alt24=43;
|
|
}
|
|
break;
|
|
case 65:
|
|
{
|
|
alt24=44;
|
|
}
|
|
break;
|
|
case 66:
|
|
{
|
|
alt24=45;
|
|
}
|
|
break;
|
|
case 67:
|
|
{
|
|
alt24=46;
|
|
}
|
|
break;
|
|
case 68:
|
|
{
|
|
alt24=47;
|
|
}
|
|
break;
|
|
case 69:
|
|
{
|
|
alt24=48;
|
|
}
|
|
break;
|
|
case 70:
|
|
{
|
|
alt24=49;
|
|
}
|
|
break;
|
|
case 71:
|
|
{
|
|
alt24=50;
|
|
}
|
|
break;
|
|
case 72:
|
|
{
|
|
alt24=51;
|
|
}
|
|
break;
|
|
case 73:
|
|
{
|
|
alt24=52;
|
|
}
|
|
break;
|
|
case 74:
|
|
{
|
|
alt24=53;
|
|
}
|
|
break;
|
|
case 75:
|
|
{
|
|
alt24=54;
|
|
}
|
|
break;
|
|
case 76:
|
|
{
|
|
alt24=55;
|
|
}
|
|
break;
|
|
case 77:
|
|
{
|
|
alt24=56;
|
|
}
|
|
break;
|
|
case 78:
|
|
{
|
|
alt24=57;
|
|
}
|
|
break;
|
|
case 79:
|
|
{
|
|
alt24=58;
|
|
}
|
|
break;
|
|
case 80:
|
|
{
|
|
alt24=59;
|
|
}
|
|
break;
|
|
case 81:
|
|
{
|
|
alt24=60;
|
|
}
|
|
break;
|
|
case 82:
|
|
{
|
|
alt24=61;
|
|
}
|
|
break;
|
|
case 83:
|
|
{
|
|
alt24=62;
|
|
}
|
|
break;
|
|
case 84:
|
|
{
|
|
alt24=63;
|
|
}
|
|
break;
|
|
case 85:
|
|
{
|
|
alt24=64;
|
|
}
|
|
break;
|
|
case 86:
|
|
{
|
|
alt24=65;
|
|
}
|
|
break;
|
|
case 87:
|
|
{
|
|
alt24=66;
|
|
}
|
|
break;
|
|
case 88:
|
|
{
|
|
alt24=67;
|
|
}
|
|
break;
|
|
case 89:
|
|
{
|
|
alt24=68;
|
|
}
|
|
break;
|
|
case 90:
|
|
{
|
|
alt24=69;
|
|
}
|
|
break;
|
|
case 91:
|
|
{
|
|
alt24=70;
|
|
}
|
|
break;
|
|
case 92:
|
|
{
|
|
alt24=71;
|
|
}
|
|
break;
|
|
case 93:
|
|
{
|
|
alt24=72;
|
|
}
|
|
break;
|
|
case 94:
|
|
{
|
|
alt24=73;
|
|
}
|
|
break;
|
|
case 95:
|
|
{
|
|
alt24=74;
|
|
}
|
|
break;
|
|
case 96:
|
|
{
|
|
alt24=75;
|
|
}
|
|
break;
|
|
default:
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 24, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt24) {
|
|
case 1 :
|
|
// InternalRDL.g:1397:2: ( ( 'name' ) )
|
|
{
|
|
// InternalRDL.g:1397:2: ( ( 'name' ) )
|
|
// InternalRDL.g:1398:3: ( 'name' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getNAMEEnumLiteralDeclaration_0());
|
|
}
|
|
// InternalRDL.g:1399:3: ( 'name' )
|
|
// InternalRDL.g:1399:4: 'name'
|
|
{
|
|
match(input,22,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getNAMEEnumLiteralDeclaration_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1403:2: ( ( 'desc' ) )
|
|
{
|
|
// InternalRDL.g:1403:2: ( ( 'desc' ) )
|
|
// InternalRDL.g:1404:3: ( 'desc' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getDESCEnumLiteralDeclaration_1());
|
|
}
|
|
// InternalRDL.g:1405:3: ( 'desc' )
|
|
// InternalRDL.g:1405:4: 'desc'
|
|
{
|
|
match(input,23,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getDESCEnumLiteralDeclaration_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:1409:2: ( ( 'arbiter' ) )
|
|
{
|
|
// InternalRDL.g:1409:2: ( ( 'arbiter' ) )
|
|
// InternalRDL.g:1410:3: ( 'arbiter' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getARBITEREnumLiteralDeclaration_2());
|
|
}
|
|
// InternalRDL.g:1411:3: ( 'arbiter' )
|
|
// InternalRDL.g:1411:4: 'arbiter'
|
|
{
|
|
match(input,24,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getARBITEREnumLiteralDeclaration_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:1415:2: ( ( 'rset' ) )
|
|
{
|
|
// InternalRDL.g:1415:2: ( ( 'rset' ) )
|
|
// InternalRDL.g:1416:3: ( 'rset' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getRSETEnumLiteralDeclaration_3());
|
|
}
|
|
// InternalRDL.g:1417:3: ( 'rset' )
|
|
// InternalRDL.g:1417:4: 'rset'
|
|
{
|
|
match(input,25,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getRSETEnumLiteralDeclaration_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 5 :
|
|
// InternalRDL.g:1421:2: ( ( 'rclr' ) )
|
|
{
|
|
// InternalRDL.g:1421:2: ( ( 'rclr' ) )
|
|
// InternalRDL.g:1422:3: ( 'rclr' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getRCLREnumLiteralDeclaration_4());
|
|
}
|
|
// InternalRDL.g:1423:3: ( 'rclr' )
|
|
// InternalRDL.g:1423:4: 'rclr'
|
|
{
|
|
match(input,26,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getRCLREnumLiteralDeclaration_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 6 :
|
|
// InternalRDL.g:1427:2: ( ( 'woclr' ) )
|
|
{
|
|
// InternalRDL.g:1427:2: ( ( 'woclr' ) )
|
|
// InternalRDL.g:1428:3: ( 'woclr' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getWOCLREnumLiteralDeclaration_5());
|
|
}
|
|
// InternalRDL.g:1429:3: ( 'woclr' )
|
|
// InternalRDL.g:1429:4: 'woclr'
|
|
{
|
|
match(input,27,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getWOCLREnumLiteralDeclaration_5());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 7 :
|
|
// InternalRDL.g:1433:2: ( ( 'woset' ) )
|
|
{
|
|
// InternalRDL.g:1433:2: ( ( 'woset' ) )
|
|
// InternalRDL.g:1434:3: ( 'woset' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getWOSETEnumLiteralDeclaration_6());
|
|
}
|
|
// InternalRDL.g:1435:3: ( 'woset' )
|
|
// InternalRDL.g:1435:4: 'woset'
|
|
{
|
|
match(input,28,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getWOSETEnumLiteralDeclaration_6());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 8 :
|
|
// InternalRDL.g:1439:2: ( ( 'we' ) )
|
|
{
|
|
// InternalRDL.g:1439:2: ( ( 'we' ) )
|
|
// InternalRDL.g:1440:3: ( 'we' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getWEEnumLiteralDeclaration_7());
|
|
}
|
|
// InternalRDL.g:1441:3: ( 'we' )
|
|
// InternalRDL.g:1441:4: 'we'
|
|
{
|
|
match(input,29,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getWEEnumLiteralDeclaration_7());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 9 :
|
|
// InternalRDL.g:1445:2: ( ( 'wel' ) )
|
|
{
|
|
// InternalRDL.g:1445:2: ( ( 'wel' ) )
|
|
// InternalRDL.g:1446:3: ( 'wel' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getWELEnumLiteralDeclaration_8());
|
|
}
|
|
// InternalRDL.g:1447:3: ( 'wel' )
|
|
// InternalRDL.g:1447:4: 'wel'
|
|
{
|
|
match(input,30,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getWELEnumLiteralDeclaration_8());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 10 :
|
|
// InternalRDL.g:1451:2: ( ( 'swwe' ) )
|
|
{
|
|
// InternalRDL.g:1451:2: ( ( 'swwe' ) )
|
|
// InternalRDL.g:1452:3: ( 'swwe' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSWWEEnumLiteralDeclaration_9());
|
|
}
|
|
// InternalRDL.g:1453:3: ( 'swwe' )
|
|
// InternalRDL.g:1453:4: 'swwe'
|
|
{
|
|
match(input,31,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSWWEEnumLiteralDeclaration_9());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 11 :
|
|
// InternalRDL.g:1457:2: ( ( 'swwel' ) )
|
|
{
|
|
// InternalRDL.g:1457:2: ( ( 'swwel' ) )
|
|
// InternalRDL.g:1458:3: ( 'swwel' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSWWELEnumLiteralDeclaration_10());
|
|
}
|
|
// InternalRDL.g:1459:3: ( 'swwel' )
|
|
// InternalRDL.g:1459:4: 'swwel'
|
|
{
|
|
match(input,32,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSWWELEnumLiteralDeclaration_10());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 12 :
|
|
// InternalRDL.g:1463:2: ( ( 'hwset' ) )
|
|
{
|
|
// InternalRDL.g:1463:2: ( ( 'hwset' ) )
|
|
// InternalRDL.g:1464:3: ( 'hwset' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getHWSETEnumLiteralDeclaration_11());
|
|
}
|
|
// InternalRDL.g:1465:3: ( 'hwset' )
|
|
// InternalRDL.g:1465:4: 'hwset'
|
|
{
|
|
match(input,33,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getHWSETEnumLiteralDeclaration_11());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 13 :
|
|
// InternalRDL.g:1469:2: ( ( 'hwclr' ) )
|
|
{
|
|
// InternalRDL.g:1469:2: ( ( 'hwclr' ) )
|
|
// InternalRDL.g:1470:3: ( 'hwclr' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getHWCLREnumLiteralDeclaration_12());
|
|
}
|
|
// InternalRDL.g:1471:3: ( 'hwclr' )
|
|
// InternalRDL.g:1471:4: 'hwclr'
|
|
{
|
|
match(input,34,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getHWCLREnumLiteralDeclaration_12());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 14 :
|
|
// InternalRDL.g:1475:2: ( ( 'swmod' ) )
|
|
{
|
|
// InternalRDL.g:1475:2: ( ( 'swmod' ) )
|
|
// InternalRDL.g:1476:3: ( 'swmod' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSWMODEnumLiteralDeclaration_13());
|
|
}
|
|
// InternalRDL.g:1477:3: ( 'swmod' )
|
|
// InternalRDL.g:1477:4: 'swmod'
|
|
{
|
|
match(input,35,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSWMODEnumLiteralDeclaration_13());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 15 :
|
|
// InternalRDL.g:1481:2: ( ( 'swacc' ) )
|
|
{
|
|
// InternalRDL.g:1481:2: ( ( 'swacc' ) )
|
|
// InternalRDL.g:1482:3: ( 'swacc' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSWACCEnumLiteralDeclaration_14());
|
|
}
|
|
// InternalRDL.g:1483:3: ( 'swacc' )
|
|
// InternalRDL.g:1483:4: 'swacc'
|
|
{
|
|
match(input,36,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSWACCEnumLiteralDeclaration_14());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 16 :
|
|
// InternalRDL.g:1487:2: ( ( 'sticky' ) )
|
|
{
|
|
// InternalRDL.g:1487:2: ( ( 'sticky' ) )
|
|
// InternalRDL.g:1488:3: ( 'sticky' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSTICKYEnumLiteralDeclaration_15());
|
|
}
|
|
// InternalRDL.g:1489:3: ( 'sticky' )
|
|
// InternalRDL.g:1489:4: 'sticky'
|
|
{
|
|
match(input,37,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSTICKYEnumLiteralDeclaration_15());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 17 :
|
|
// InternalRDL.g:1493:2: ( ( 'stickybit' ) )
|
|
{
|
|
// InternalRDL.g:1493:2: ( ( 'stickybit' ) )
|
|
// InternalRDL.g:1494:3: ( 'stickybit' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSTICKYBITEnumLiteralDeclaration_16());
|
|
}
|
|
// InternalRDL.g:1495:3: ( 'stickybit' )
|
|
// InternalRDL.g:1495:4: 'stickybit'
|
|
{
|
|
match(input,38,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSTICKYBITEnumLiteralDeclaration_16());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 18 :
|
|
// InternalRDL.g:1499:2: ( ( 'intr' ) )
|
|
{
|
|
// InternalRDL.g:1499:2: ( ( 'intr' ) )
|
|
// InternalRDL.g:1500:3: ( 'intr' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getINTREnumLiteralDeclaration_17());
|
|
}
|
|
// InternalRDL.g:1501:3: ( 'intr' )
|
|
// InternalRDL.g:1501:4: 'intr'
|
|
{
|
|
match(input,39,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getINTREnumLiteralDeclaration_17());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 19 :
|
|
// InternalRDL.g:1505:2: ( ( 'anded' ) )
|
|
{
|
|
// InternalRDL.g:1505:2: ( ( 'anded' ) )
|
|
// InternalRDL.g:1506:3: ( 'anded' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getANDEDEnumLiteralDeclaration_18());
|
|
}
|
|
// InternalRDL.g:1507:3: ( 'anded' )
|
|
// InternalRDL.g:1507:4: 'anded'
|
|
{
|
|
match(input,40,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getANDEDEnumLiteralDeclaration_18());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 20 :
|
|
// InternalRDL.g:1511:2: ( ( 'ored' ) )
|
|
{
|
|
// InternalRDL.g:1511:2: ( ( 'ored' ) )
|
|
// InternalRDL.g:1512:3: ( 'ored' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getOREDEnumLiteralDeclaration_19());
|
|
}
|
|
// InternalRDL.g:1513:3: ( 'ored' )
|
|
// InternalRDL.g:1513:4: 'ored'
|
|
{
|
|
match(input,41,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getOREDEnumLiteralDeclaration_19());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 21 :
|
|
// InternalRDL.g:1517:2: ( ( 'xored' ) )
|
|
{
|
|
// InternalRDL.g:1517:2: ( ( 'xored' ) )
|
|
// InternalRDL.g:1518:3: ( 'xored' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getXOREDEnumLiteralDeclaration_20());
|
|
}
|
|
// InternalRDL.g:1519:3: ( 'xored' )
|
|
// InternalRDL.g:1519:4: 'xored'
|
|
{
|
|
match(input,42,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getXOREDEnumLiteralDeclaration_20());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 22 :
|
|
// InternalRDL.g:1523:2: ( ( 'counter' ) )
|
|
{
|
|
// InternalRDL.g:1523:2: ( ( 'counter' ) )
|
|
// InternalRDL.g:1524:3: ( 'counter' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getCOUNTEREnumLiteralDeclaration_21());
|
|
}
|
|
// InternalRDL.g:1525:3: ( 'counter' )
|
|
// InternalRDL.g:1525:4: 'counter'
|
|
{
|
|
match(input,43,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getCOUNTEREnumLiteralDeclaration_21());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 23 :
|
|
// InternalRDL.g:1529:2: ( ( 'overflow' ) )
|
|
{
|
|
// InternalRDL.g:1529:2: ( ( 'overflow' ) )
|
|
// InternalRDL.g:1530:3: ( 'overflow' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getOVERFLOWEnumLiteralDeclaration_22());
|
|
}
|
|
// InternalRDL.g:1531:3: ( 'overflow' )
|
|
// InternalRDL.g:1531:4: 'overflow'
|
|
{
|
|
match(input,44,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getOVERFLOWEnumLiteralDeclaration_22());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 24 :
|
|
// InternalRDL.g:1535:2: ( ( 'sharedextbus' ) )
|
|
{
|
|
// InternalRDL.g:1535:2: ( ( 'sharedextbus' ) )
|
|
// InternalRDL.g:1536:3: ( 'sharedextbus' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSHAREDEXTBUSEnumLiteralDeclaration_23());
|
|
}
|
|
// InternalRDL.g:1537:3: ( 'sharedextbus' )
|
|
// InternalRDL.g:1537:4: 'sharedextbus'
|
|
{
|
|
match(input,45,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSHAREDEXTBUSEnumLiteralDeclaration_23());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 25 :
|
|
// InternalRDL.g:1541:2: ( ( 'errextbus' ) )
|
|
{
|
|
// InternalRDL.g:1541:2: ( ( 'errextbus' ) )
|
|
// InternalRDL.g:1542:3: ( 'errextbus' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getERREXTBUSEnumLiteralDeclaration_24());
|
|
}
|
|
// InternalRDL.g:1543:3: ( 'errextbus' )
|
|
// InternalRDL.g:1543:4: 'errextbus'
|
|
{
|
|
match(input,46,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getERREXTBUSEnumLiteralDeclaration_24());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 26 :
|
|
// InternalRDL.g:1547:2: ( ( 'reset' ) )
|
|
{
|
|
// InternalRDL.g:1547:2: ( ( 'reset' ) )
|
|
// InternalRDL.g:1548:3: ( 'reset' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getRESETEnumLiteralDeclaration_25());
|
|
}
|
|
// InternalRDL.g:1549:3: ( 'reset' )
|
|
// InternalRDL.g:1549:4: 'reset'
|
|
{
|
|
match(input,47,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getRESETEnumLiteralDeclaration_25());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 27 :
|
|
// InternalRDL.g:1553:2: ( ( 'littleendian' ) )
|
|
{
|
|
// InternalRDL.g:1553:2: ( ( 'littleendian' ) )
|
|
// InternalRDL.g:1554:3: ( 'littleendian' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getLITTLEENDIANEnumLiteralDeclaration_26());
|
|
}
|
|
// InternalRDL.g:1555:3: ( 'littleendian' )
|
|
// InternalRDL.g:1555:4: 'littleendian'
|
|
{
|
|
match(input,48,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getLITTLEENDIANEnumLiteralDeclaration_26());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 28 :
|
|
// InternalRDL.g:1559:2: ( ( 'bigendian' ) )
|
|
{
|
|
// InternalRDL.g:1559:2: ( ( 'bigendian' ) )
|
|
// InternalRDL.g:1560:3: ( 'bigendian' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getBIGENDIANEnumLiteralDeclaration_27());
|
|
}
|
|
// InternalRDL.g:1561:3: ( 'bigendian' )
|
|
// InternalRDL.g:1561:4: 'bigendian'
|
|
{
|
|
match(input,49,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getBIGENDIANEnumLiteralDeclaration_27());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 29 :
|
|
// InternalRDL.g:1565:2: ( ( 'rsvdset' ) )
|
|
{
|
|
// InternalRDL.g:1565:2: ( ( 'rsvdset' ) )
|
|
// InternalRDL.g:1566:3: ( 'rsvdset' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getRSVDSETEnumLiteralDeclaration_28());
|
|
}
|
|
// InternalRDL.g:1567:3: ( 'rsvdset' )
|
|
// InternalRDL.g:1567:4: 'rsvdset'
|
|
{
|
|
match(input,50,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getRSVDSETEnumLiteralDeclaration_28());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 30 :
|
|
// InternalRDL.g:1571:2: ( ( 'rsvdsetX' ) )
|
|
{
|
|
// InternalRDL.g:1571:2: ( ( 'rsvdsetX' ) )
|
|
// InternalRDL.g:1572:3: ( 'rsvdsetX' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getRSVDSETXEnumLiteralDeclaration_29());
|
|
}
|
|
// InternalRDL.g:1573:3: ( 'rsvdsetX' )
|
|
// InternalRDL.g:1573:4: 'rsvdsetX'
|
|
{
|
|
match(input,51,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getRSVDSETXEnumLiteralDeclaration_29());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 31 :
|
|
// InternalRDL.g:1577:2: ( ( 'bridge' ) )
|
|
{
|
|
// InternalRDL.g:1577:2: ( ( 'bridge' ) )
|
|
// InternalRDL.g:1578:3: ( 'bridge' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getBRIDGEEnumLiteralDeclaration_30());
|
|
}
|
|
// InternalRDL.g:1579:3: ( 'bridge' )
|
|
// InternalRDL.g:1579:4: 'bridge'
|
|
{
|
|
match(input,52,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getBRIDGEEnumLiteralDeclaration_30());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 32 :
|
|
// InternalRDL.g:1583:2: ( ( 'shared' ) )
|
|
{
|
|
// InternalRDL.g:1583:2: ( ( 'shared' ) )
|
|
// InternalRDL.g:1584:3: ( 'shared' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSHAREDEnumLiteralDeclaration_31());
|
|
}
|
|
// InternalRDL.g:1585:3: ( 'shared' )
|
|
// InternalRDL.g:1585:4: 'shared'
|
|
{
|
|
match(input,53,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSHAREDEnumLiteralDeclaration_31());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 33 :
|
|
// InternalRDL.g:1589:2: ( ( 'msb0' ) )
|
|
{
|
|
// InternalRDL.g:1589:2: ( ( 'msb0' ) )
|
|
// InternalRDL.g:1590:3: ( 'msb0' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getMSB0EnumLiteralDeclaration_32());
|
|
}
|
|
// InternalRDL.g:1591:3: ( 'msb0' )
|
|
// InternalRDL.g:1591:4: 'msb0'
|
|
{
|
|
match(input,54,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getMSB0EnumLiteralDeclaration_32());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 34 :
|
|
// InternalRDL.g:1595:2: ( ( 'lsb0' ) )
|
|
{
|
|
// InternalRDL.g:1595:2: ( ( 'lsb0' ) )
|
|
// InternalRDL.g:1596:3: ( 'lsb0' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getLSB0EnumLiteralDeclaration_33());
|
|
}
|
|
// InternalRDL.g:1597:3: ( 'lsb0' )
|
|
// InternalRDL.g:1597:4: 'lsb0'
|
|
{
|
|
match(input,55,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getLSB0EnumLiteralDeclaration_33());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 35 :
|
|
// InternalRDL.g:1601:2: ( ( 'sync' ) )
|
|
{
|
|
// InternalRDL.g:1601:2: ( ( 'sync' ) )
|
|
// InternalRDL.g:1602:3: ( 'sync' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSYNCEnumLiteralDeclaration_34());
|
|
}
|
|
// InternalRDL.g:1603:3: ( 'sync' )
|
|
// InternalRDL.g:1603:4: 'sync'
|
|
{
|
|
match(input,56,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSYNCEnumLiteralDeclaration_34());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 36 :
|
|
// InternalRDL.g:1607:2: ( ( 'async' ) )
|
|
{
|
|
// InternalRDL.g:1607:2: ( ( 'async' ) )
|
|
// InternalRDL.g:1608:3: ( 'async' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getASYNCEnumLiteralDeclaration_35());
|
|
}
|
|
// InternalRDL.g:1609:3: ( 'async' )
|
|
// InternalRDL.g:1609:4: 'async'
|
|
{
|
|
match(input,57,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getASYNCEnumLiteralDeclaration_35());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 37 :
|
|
// InternalRDL.g:1613:2: ( ( 'cpuif_reset' ) )
|
|
{
|
|
// InternalRDL.g:1613:2: ( ( 'cpuif_reset' ) )
|
|
// InternalRDL.g:1614:3: ( 'cpuif_reset' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getCPUIF_RESETEnumLiteralDeclaration_36());
|
|
}
|
|
// InternalRDL.g:1615:3: ( 'cpuif_reset' )
|
|
// InternalRDL.g:1615:4: 'cpuif_reset'
|
|
{
|
|
match(input,58,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getCPUIF_RESETEnumLiteralDeclaration_36());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 38 :
|
|
// InternalRDL.g:1619:2: ( ( 'field_reset' ) )
|
|
{
|
|
// InternalRDL.g:1619:2: ( ( 'field_reset' ) )
|
|
// InternalRDL.g:1620:3: ( 'field_reset' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getFIELD_RESETEnumLiteralDeclaration_37());
|
|
}
|
|
// InternalRDL.g:1621:3: ( 'field_reset' )
|
|
// InternalRDL.g:1621:4: 'field_reset'
|
|
{
|
|
match(input,59,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getFIELD_RESETEnumLiteralDeclaration_37());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 39 :
|
|
// InternalRDL.g:1625:2: ( ( 'activehigh' ) )
|
|
{
|
|
// InternalRDL.g:1625:2: ( ( 'activehigh' ) )
|
|
// InternalRDL.g:1626:3: ( 'activehigh' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getACTIVEHIGHEnumLiteralDeclaration_38());
|
|
}
|
|
// InternalRDL.g:1627:3: ( 'activehigh' )
|
|
// InternalRDL.g:1627:4: 'activehigh'
|
|
{
|
|
match(input,60,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getACTIVEHIGHEnumLiteralDeclaration_38());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 40 :
|
|
// InternalRDL.g:1631:2: ( ( 'activelow' ) )
|
|
{
|
|
// InternalRDL.g:1631:2: ( ( 'activelow' ) )
|
|
// InternalRDL.g:1632:3: ( 'activelow' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getACTIVELOWEnumLiteralDeclaration_39());
|
|
}
|
|
// InternalRDL.g:1633:3: ( 'activelow' )
|
|
// InternalRDL.g:1633:4: 'activelow'
|
|
{
|
|
match(input,61,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getACTIVELOWEnumLiteralDeclaration_39());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 41 :
|
|
// InternalRDL.g:1637:2: ( ( 'singlepulse' ) )
|
|
{
|
|
// InternalRDL.g:1637:2: ( ( 'singlepulse' ) )
|
|
// InternalRDL.g:1638:3: ( 'singlepulse' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSINGLEPULSEEnumLiteralDeclaration_40());
|
|
}
|
|
// InternalRDL.g:1639:3: ( 'singlepulse' )
|
|
// InternalRDL.g:1639:4: 'singlepulse'
|
|
{
|
|
match(input,62,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSINGLEPULSEEnumLiteralDeclaration_40());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 42 :
|
|
// InternalRDL.g:1643:2: ( ( 'underflow' ) )
|
|
{
|
|
// InternalRDL.g:1643:2: ( ( 'underflow' ) )
|
|
// InternalRDL.g:1644:3: ( 'underflow' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getUNDERFLOWEnumLiteralDeclaration_41());
|
|
}
|
|
// InternalRDL.g:1645:3: ( 'underflow' )
|
|
// InternalRDL.g:1645:4: 'underflow'
|
|
{
|
|
match(input,63,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getUNDERFLOWEnumLiteralDeclaration_41());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 43 :
|
|
// InternalRDL.g:1649:2: ( ( 'incr' ) )
|
|
{
|
|
// InternalRDL.g:1649:2: ( ( 'incr' ) )
|
|
// InternalRDL.g:1650:3: ( 'incr' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getINCREnumLiteralDeclaration_42());
|
|
}
|
|
// InternalRDL.g:1651:3: ( 'incr' )
|
|
// InternalRDL.g:1651:4: 'incr'
|
|
{
|
|
match(input,64,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getINCREnumLiteralDeclaration_42());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 44 :
|
|
// InternalRDL.g:1655:2: ( ( 'decr' ) )
|
|
{
|
|
// InternalRDL.g:1655:2: ( ( 'decr' ) )
|
|
// InternalRDL.g:1656:3: ( 'decr' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getDECREnumLiteralDeclaration_43());
|
|
}
|
|
// InternalRDL.g:1657:3: ( 'decr' )
|
|
// InternalRDL.g:1657:4: 'decr'
|
|
{
|
|
match(input,65,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getDECREnumLiteralDeclaration_43());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 45 :
|
|
// InternalRDL.g:1661:2: ( ( 'incrwidth' ) )
|
|
{
|
|
// InternalRDL.g:1661:2: ( ( 'incrwidth' ) )
|
|
// InternalRDL.g:1662:3: ( 'incrwidth' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getINCRWIDTHEnumLiteralDeclaration_44());
|
|
}
|
|
// InternalRDL.g:1663:3: ( 'incrwidth' )
|
|
// InternalRDL.g:1663:4: 'incrwidth'
|
|
{
|
|
match(input,66,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getINCRWIDTHEnumLiteralDeclaration_44());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 46 :
|
|
// InternalRDL.g:1667:2: ( ( 'decrwidth' ) )
|
|
{
|
|
// InternalRDL.g:1667:2: ( ( 'decrwidth' ) )
|
|
// InternalRDL.g:1668:3: ( 'decrwidth' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getDECRWIDTHEnumLiteralDeclaration_45());
|
|
}
|
|
// InternalRDL.g:1669:3: ( 'decrwidth' )
|
|
// InternalRDL.g:1669:4: 'decrwidth'
|
|
{
|
|
match(input,67,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getDECRWIDTHEnumLiteralDeclaration_45());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 47 :
|
|
// InternalRDL.g:1673:2: ( ( 'incrvalue' ) )
|
|
{
|
|
// InternalRDL.g:1673:2: ( ( 'incrvalue' ) )
|
|
// InternalRDL.g:1674:3: ( 'incrvalue' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getINCRVALUEEnumLiteralDeclaration_46());
|
|
}
|
|
// InternalRDL.g:1675:3: ( 'incrvalue' )
|
|
// InternalRDL.g:1675:4: 'incrvalue'
|
|
{
|
|
match(input,68,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getINCRVALUEEnumLiteralDeclaration_46());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 48 :
|
|
// InternalRDL.g:1679:2: ( ( 'decrvalue' ) )
|
|
{
|
|
// InternalRDL.g:1679:2: ( ( 'decrvalue' ) )
|
|
// InternalRDL.g:1680:3: ( 'decrvalue' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getDECRVALUEEnumLiteralDeclaration_47());
|
|
}
|
|
// InternalRDL.g:1681:3: ( 'decrvalue' )
|
|
// InternalRDL.g:1681:4: 'decrvalue'
|
|
{
|
|
match(input,69,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getDECRVALUEEnumLiteralDeclaration_47());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 49 :
|
|
// InternalRDL.g:1685:2: ( ( 'saturate' ) )
|
|
{
|
|
// InternalRDL.g:1685:2: ( ( 'saturate' ) )
|
|
// InternalRDL.g:1686:3: ( 'saturate' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSATURATEEnumLiteralDeclaration_48());
|
|
}
|
|
// InternalRDL.g:1687:3: ( 'saturate' )
|
|
// InternalRDL.g:1687:4: 'saturate'
|
|
{
|
|
match(input,70,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSATURATEEnumLiteralDeclaration_48());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 50 :
|
|
// InternalRDL.g:1691:2: ( ( 'decrsaturate' ) )
|
|
{
|
|
// InternalRDL.g:1691:2: ( ( 'decrsaturate' ) )
|
|
// InternalRDL.g:1692:3: ( 'decrsaturate' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getDECRSATURATEEnumLiteralDeclaration_49());
|
|
}
|
|
// InternalRDL.g:1693:3: ( 'decrsaturate' )
|
|
// InternalRDL.g:1693:4: 'decrsaturate'
|
|
{
|
|
match(input,71,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getDECRSATURATEEnumLiteralDeclaration_49());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 51 :
|
|
// InternalRDL.g:1697:2: ( ( 'threshold' ) )
|
|
{
|
|
// InternalRDL.g:1697:2: ( ( 'threshold' ) )
|
|
// InternalRDL.g:1698:3: ( 'threshold' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getTHRESHOLDEnumLiteralDeclaration_50());
|
|
}
|
|
// InternalRDL.g:1699:3: ( 'threshold' )
|
|
// InternalRDL.g:1699:4: 'threshold'
|
|
{
|
|
match(input,72,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getTHRESHOLDEnumLiteralDeclaration_50());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 52 :
|
|
// InternalRDL.g:1703:2: ( ( 'decrthreshold' ) )
|
|
{
|
|
// InternalRDL.g:1703:2: ( ( 'decrthreshold' ) )
|
|
// InternalRDL.g:1704:3: ( 'decrthreshold' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getDECRTHRESHOLDEnumLiteralDeclaration_51());
|
|
}
|
|
// InternalRDL.g:1705:3: ( 'decrthreshold' )
|
|
// InternalRDL.g:1705:4: 'decrthreshold'
|
|
{
|
|
match(input,73,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getDECRTHRESHOLDEnumLiteralDeclaration_51());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 53 :
|
|
// InternalRDL.g:1709:2: ( ( 'dontcompare' ) )
|
|
{
|
|
// InternalRDL.g:1709:2: ( ( 'dontcompare' ) )
|
|
// InternalRDL.g:1710:3: ( 'dontcompare' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getDONTCOMPAREEnumLiteralDeclaration_52());
|
|
}
|
|
// InternalRDL.g:1711:3: ( 'dontcompare' )
|
|
// InternalRDL.g:1711:4: 'dontcompare'
|
|
{
|
|
match(input,74,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getDONTCOMPAREEnumLiteralDeclaration_52());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 54 :
|
|
// InternalRDL.g:1715:2: ( ( 'donttest' ) )
|
|
{
|
|
// InternalRDL.g:1715:2: ( ( 'donttest' ) )
|
|
// InternalRDL.g:1716:3: ( 'donttest' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getDONTTESTEnumLiteralDeclaration_53());
|
|
}
|
|
// InternalRDL.g:1717:3: ( 'donttest' )
|
|
// InternalRDL.g:1717:4: 'donttest'
|
|
{
|
|
match(input,75,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getDONTTESTEnumLiteralDeclaration_53());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 55 :
|
|
// InternalRDL.g:1721:2: ( ( 'internal' ) )
|
|
{
|
|
// InternalRDL.g:1721:2: ( ( 'internal' ) )
|
|
// InternalRDL.g:1722:3: ( 'internal' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getINTERNALEnumLiteralDeclaration_54());
|
|
}
|
|
// InternalRDL.g:1723:3: ( 'internal' )
|
|
// InternalRDL.g:1723:4: 'internal'
|
|
{
|
|
match(input,76,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getINTERNALEnumLiteralDeclaration_54());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 56 :
|
|
// InternalRDL.g:1727:2: ( ( 'alignment' ) )
|
|
{
|
|
// InternalRDL.g:1727:2: ( ( 'alignment' ) )
|
|
// InternalRDL.g:1728:3: ( 'alignment' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getALIGNMENTEnumLiteralDeclaration_55());
|
|
}
|
|
// InternalRDL.g:1729:3: ( 'alignment' )
|
|
// InternalRDL.g:1729:4: 'alignment'
|
|
{
|
|
match(input,77,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getALIGNMENTEnumLiteralDeclaration_55());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 57 :
|
|
// InternalRDL.g:1733:2: ( ( 'regwidth' ) )
|
|
{
|
|
// InternalRDL.g:1733:2: ( ( 'regwidth' ) )
|
|
// InternalRDL.g:1734:3: ( 'regwidth' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getREGWIDTHEnumLiteralDeclaration_56());
|
|
}
|
|
// InternalRDL.g:1735:3: ( 'regwidth' )
|
|
// InternalRDL.g:1735:4: 'regwidth'
|
|
{
|
|
match(input,78,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getREGWIDTHEnumLiteralDeclaration_56());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 58 :
|
|
// InternalRDL.g:1739:2: ( ( 'fieldwidth' ) )
|
|
{
|
|
// InternalRDL.g:1739:2: ( ( 'fieldwidth' ) )
|
|
// InternalRDL.g:1740:3: ( 'fieldwidth' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getFIELDWIDTHEnumLiteralDeclaration_57());
|
|
}
|
|
// InternalRDL.g:1741:3: ( 'fieldwidth' )
|
|
// InternalRDL.g:1741:4: 'fieldwidth'
|
|
{
|
|
match(input,79,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getFIELDWIDTHEnumLiteralDeclaration_57());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 59 :
|
|
// InternalRDL.g:1745:2: ( ( 'signalwidth' ) )
|
|
{
|
|
// InternalRDL.g:1745:2: ( ( 'signalwidth' ) )
|
|
// InternalRDL.g:1746:3: ( 'signalwidth' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSIGNALWIDTHEnumLiteralDeclaration_58());
|
|
}
|
|
// InternalRDL.g:1747:3: ( 'signalwidth' )
|
|
// InternalRDL.g:1747:4: 'signalwidth'
|
|
{
|
|
match(input,80,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSIGNALWIDTHEnumLiteralDeclaration_58());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 60 :
|
|
// InternalRDL.g:1751:2: ( ( 'accesswidth' ) )
|
|
{
|
|
// InternalRDL.g:1751:2: ( ( 'accesswidth' ) )
|
|
// InternalRDL.g:1752:3: ( 'accesswidth' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getACCESSWIDTHEnumLiteralDeclaration_59());
|
|
}
|
|
// InternalRDL.g:1753:3: ( 'accesswidth' )
|
|
// InternalRDL.g:1753:4: 'accesswidth'
|
|
{
|
|
match(input,81,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getACCESSWIDTHEnumLiteralDeclaration_59());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 61 :
|
|
// InternalRDL.g:1757:2: ( ( 'sw' ) )
|
|
{
|
|
// InternalRDL.g:1757:2: ( ( 'sw' ) )
|
|
// InternalRDL.g:1758:3: ( 'sw' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getSWEnumLiteralDeclaration_60());
|
|
}
|
|
// InternalRDL.g:1759:3: ( 'sw' )
|
|
// InternalRDL.g:1759:4: 'sw'
|
|
{
|
|
match(input,82,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getSWEnumLiteralDeclaration_60());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 62 :
|
|
// InternalRDL.g:1763:2: ( ( 'hw' ) )
|
|
{
|
|
// InternalRDL.g:1763:2: ( ( 'hw' ) )
|
|
// InternalRDL.g:1764:3: ( 'hw' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getHWEnumLiteralDeclaration_61());
|
|
}
|
|
// InternalRDL.g:1765:3: ( 'hw' )
|
|
// InternalRDL.g:1765:4: 'hw'
|
|
{
|
|
match(input,83,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getHWEnumLiteralDeclaration_61());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 63 :
|
|
// InternalRDL.g:1769:2: ( ( 'addressing' ) )
|
|
{
|
|
// InternalRDL.g:1769:2: ( ( 'addressing' ) )
|
|
// InternalRDL.g:1770:3: ( 'addressing' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getADDRESSINGEnumLiteralDeclaration_62());
|
|
}
|
|
// InternalRDL.g:1771:3: ( 'addressing' )
|
|
// InternalRDL.g:1771:4: 'addressing'
|
|
{
|
|
match(input,84,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getADDRESSINGEnumLiteralDeclaration_62());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 64 :
|
|
// InternalRDL.g:1775:2: ( ( 'precedence' ) )
|
|
{
|
|
// InternalRDL.g:1775:2: ( ( 'precedence' ) )
|
|
// InternalRDL.g:1776:3: ( 'precedence' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getPRECEDENCEEnumLiteralDeclaration_63());
|
|
}
|
|
// InternalRDL.g:1777:3: ( 'precedence' )
|
|
// InternalRDL.g:1777:4: 'precedence'
|
|
{
|
|
match(input,85,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getPRECEDENCEEnumLiteralDeclaration_63());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 65 :
|
|
// InternalRDL.g:1781:2: ( ( 'encode' ) )
|
|
{
|
|
// InternalRDL.g:1781:2: ( ( 'encode' ) )
|
|
// InternalRDL.g:1782:3: ( 'encode' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getENCODEEnumLiteralDeclaration_64());
|
|
}
|
|
// InternalRDL.g:1783:3: ( 'encode' )
|
|
// InternalRDL.g:1783:4: 'encode'
|
|
{
|
|
match(input,86,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getENCODEEnumLiteralDeclaration_64());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 66 :
|
|
// InternalRDL.g:1787:2: ( ( 'resetsignal' ) )
|
|
{
|
|
// InternalRDL.g:1787:2: ( ( 'resetsignal' ) )
|
|
// InternalRDL.g:1788:3: ( 'resetsignal' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getRESETSIGNALEnumLiteralDeclaration_65());
|
|
}
|
|
// InternalRDL.g:1789:3: ( 'resetsignal' )
|
|
// InternalRDL.g:1789:4: 'resetsignal'
|
|
{
|
|
match(input,87,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getRESETSIGNALEnumLiteralDeclaration_65());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 67 :
|
|
// InternalRDL.g:1793:2: ( ( 'clock' ) )
|
|
{
|
|
// InternalRDL.g:1793:2: ( ( 'clock' ) )
|
|
// InternalRDL.g:1794:3: ( 'clock' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getCLOCKEnumLiteralDeclaration_66());
|
|
}
|
|
// InternalRDL.g:1795:3: ( 'clock' )
|
|
// InternalRDL.g:1795:4: 'clock'
|
|
{
|
|
match(input,88,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getCLOCKEnumLiteralDeclaration_66());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 68 :
|
|
// InternalRDL.g:1799:2: ( ( 'mask' ) )
|
|
{
|
|
// InternalRDL.g:1799:2: ( ( 'mask' ) )
|
|
// InternalRDL.g:1800:3: ( 'mask' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getMASKEnumLiteralDeclaration_67());
|
|
}
|
|
// InternalRDL.g:1801:3: ( 'mask' )
|
|
// InternalRDL.g:1801:4: 'mask'
|
|
{
|
|
match(input,89,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getMASKEnumLiteralDeclaration_67());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 69 :
|
|
// InternalRDL.g:1805:2: ( ( 'enable' ) )
|
|
{
|
|
// InternalRDL.g:1805:2: ( ( 'enable' ) )
|
|
// InternalRDL.g:1806:3: ( 'enable' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getENABLEEnumLiteralDeclaration_68());
|
|
}
|
|
// InternalRDL.g:1807:3: ( 'enable' )
|
|
// InternalRDL.g:1807:4: 'enable'
|
|
{
|
|
match(input,90,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getENABLEEnumLiteralDeclaration_68());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 70 :
|
|
// InternalRDL.g:1811:2: ( ( 'hwenable' ) )
|
|
{
|
|
// InternalRDL.g:1811:2: ( ( 'hwenable' ) )
|
|
// InternalRDL.g:1812:3: ( 'hwenable' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getHWENABLEEnumLiteralDeclaration_69());
|
|
}
|
|
// InternalRDL.g:1813:3: ( 'hwenable' )
|
|
// InternalRDL.g:1813:4: 'hwenable'
|
|
{
|
|
match(input,91,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getHWENABLEEnumLiteralDeclaration_69());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 71 :
|
|
// InternalRDL.g:1817:2: ( ( 'hwmask' ) )
|
|
{
|
|
// InternalRDL.g:1817:2: ( ( 'hwmask' ) )
|
|
// InternalRDL.g:1818:3: ( 'hwmask' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getHWMASKEnumLiteralDeclaration_70());
|
|
}
|
|
// InternalRDL.g:1819:3: ( 'hwmask' )
|
|
// InternalRDL.g:1819:4: 'hwmask'
|
|
{
|
|
match(input,92,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getHWMASKEnumLiteralDeclaration_70());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 72 :
|
|
// InternalRDL.g:1823:2: ( ( 'haltmask' ) )
|
|
{
|
|
// InternalRDL.g:1823:2: ( ( 'haltmask' ) )
|
|
// InternalRDL.g:1824:3: ( 'haltmask' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getHALTMASKEnumLiteralDeclaration_71());
|
|
}
|
|
// InternalRDL.g:1825:3: ( 'haltmask' )
|
|
// InternalRDL.g:1825:4: 'haltmask'
|
|
{
|
|
match(input,93,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getHALTMASKEnumLiteralDeclaration_71());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 73 :
|
|
// InternalRDL.g:1829:2: ( ( 'haltenable' ) )
|
|
{
|
|
// InternalRDL.g:1829:2: ( ( 'haltenable' ) )
|
|
// InternalRDL.g:1830:3: ( 'haltenable' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getHALTENABLEEnumLiteralDeclaration_72());
|
|
}
|
|
// InternalRDL.g:1831:3: ( 'haltenable' )
|
|
// InternalRDL.g:1831:4: 'haltenable'
|
|
{
|
|
match(input,94,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getHALTENABLEEnumLiteralDeclaration_72());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 74 :
|
|
// InternalRDL.g:1835:2: ( ( 'halt' ) )
|
|
{
|
|
// InternalRDL.g:1835:2: ( ( 'halt' ) )
|
|
// InternalRDL.g:1836:3: ( 'halt' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getHALTEnumLiteralDeclaration_73());
|
|
}
|
|
// InternalRDL.g:1837:3: ( 'halt' )
|
|
// InternalRDL.g:1837:4: 'halt'
|
|
{
|
|
match(input,95,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getHALTEnumLiteralDeclaration_73());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 75 :
|
|
// InternalRDL.g:1841:2: ( ( 'next' ) )
|
|
{
|
|
// InternalRDL.g:1841:2: ( ( 'next' ) )
|
|
// InternalRDL.g:1842:3: ( 'next' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAccess().getNEXTEnumLiteralDeclaration_74());
|
|
}
|
|
// InternalRDL.g:1843:3: ( 'next' )
|
|
// InternalRDL.g:1843:4: 'next'
|
|
{
|
|
match(input,96,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAccess().getNEXTEnumLiteralDeclaration_74());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Property__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__RValueConstant__Alternatives"
|
|
// InternalRDL.g:1851:1: rule__RValueConstant__Alternatives : ( ( ( 'UNDEFINED' ) ) | ( ( 'true' ) ) | ( ( 'false' ) ) | ( ( 'rw' ) ) | ( ( 'wr' ) ) | ( ( 'r' ) ) | ( ( 'w' ) ) | ( ( 'na' ) ) | ( ( 'compact' ) ) | ( ( 'regalign' ) ) | ( ( 'fullalign' ) ) | ( ( 'hw' ) ) | ( ( 'sw' ) ) );
|
|
public final void rule__RValueConstant__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1855:1: ( ( ( 'UNDEFINED' ) ) | ( ( 'true' ) ) | ( ( 'false' ) ) | ( ( 'rw' ) ) | ( ( 'wr' ) ) | ( ( 'r' ) ) | ( ( 'w' ) ) | ( ( 'na' ) ) | ( ( 'compact' ) ) | ( ( 'regalign' ) ) | ( ( 'fullalign' ) ) | ( ( 'hw' ) ) | ( ( 'sw' ) ) )
|
|
int alt25=13;
|
|
switch ( input.LA(1) ) {
|
|
case 97:
|
|
{
|
|
alt25=1;
|
|
}
|
|
break;
|
|
case 98:
|
|
{
|
|
alt25=2;
|
|
}
|
|
break;
|
|
case 99:
|
|
{
|
|
alt25=3;
|
|
}
|
|
break;
|
|
case 100:
|
|
{
|
|
alt25=4;
|
|
}
|
|
break;
|
|
case 101:
|
|
{
|
|
alt25=5;
|
|
}
|
|
break;
|
|
case 102:
|
|
{
|
|
alt25=6;
|
|
}
|
|
break;
|
|
case 103:
|
|
{
|
|
alt25=7;
|
|
}
|
|
break;
|
|
case 104:
|
|
{
|
|
alt25=8;
|
|
}
|
|
break;
|
|
case 105:
|
|
{
|
|
alt25=9;
|
|
}
|
|
break;
|
|
case 106:
|
|
{
|
|
alt25=10;
|
|
}
|
|
break;
|
|
case 107:
|
|
{
|
|
alt25=11;
|
|
}
|
|
break;
|
|
case 83:
|
|
{
|
|
alt25=12;
|
|
}
|
|
break;
|
|
case 82:
|
|
{
|
|
alt25=13;
|
|
}
|
|
break;
|
|
default:
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 25, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt25) {
|
|
case 1 :
|
|
// InternalRDL.g:1856:2: ( ( 'UNDEFINED' ) )
|
|
{
|
|
// InternalRDL.g:1856:2: ( ( 'UNDEFINED' ) )
|
|
// InternalRDL.g:1857:3: ( 'UNDEFINED' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getUNDEFINEDEnumLiteralDeclaration_0());
|
|
}
|
|
// InternalRDL.g:1858:3: ( 'UNDEFINED' )
|
|
// InternalRDL.g:1858:4: 'UNDEFINED'
|
|
{
|
|
match(input,97,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getUNDEFINEDEnumLiteralDeclaration_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1862:2: ( ( 'true' ) )
|
|
{
|
|
// InternalRDL.g:1862:2: ( ( 'true' ) )
|
|
// InternalRDL.g:1863:3: ( 'true' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getTRUEEnumLiteralDeclaration_1());
|
|
}
|
|
// InternalRDL.g:1864:3: ( 'true' )
|
|
// InternalRDL.g:1864:4: 'true'
|
|
{
|
|
match(input,98,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getTRUEEnumLiteralDeclaration_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:1868:2: ( ( 'false' ) )
|
|
{
|
|
// InternalRDL.g:1868:2: ( ( 'false' ) )
|
|
// InternalRDL.g:1869:3: ( 'false' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getFALSEEnumLiteralDeclaration_2());
|
|
}
|
|
// InternalRDL.g:1870:3: ( 'false' )
|
|
// InternalRDL.g:1870:4: 'false'
|
|
{
|
|
match(input,99,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getFALSEEnumLiteralDeclaration_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:1874:2: ( ( 'rw' ) )
|
|
{
|
|
// InternalRDL.g:1874:2: ( ( 'rw' ) )
|
|
// InternalRDL.g:1875:3: ( 'rw' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getRWEnumLiteralDeclaration_3());
|
|
}
|
|
// InternalRDL.g:1876:3: ( 'rw' )
|
|
// InternalRDL.g:1876:4: 'rw'
|
|
{
|
|
match(input,100,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getRWEnumLiteralDeclaration_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 5 :
|
|
// InternalRDL.g:1880:2: ( ( 'wr' ) )
|
|
{
|
|
// InternalRDL.g:1880:2: ( ( 'wr' ) )
|
|
// InternalRDL.g:1881:3: ( 'wr' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getWREnumLiteralDeclaration_4());
|
|
}
|
|
// InternalRDL.g:1882:3: ( 'wr' )
|
|
// InternalRDL.g:1882:4: 'wr'
|
|
{
|
|
match(input,101,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getWREnumLiteralDeclaration_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 6 :
|
|
// InternalRDL.g:1886:2: ( ( 'r' ) )
|
|
{
|
|
// InternalRDL.g:1886:2: ( ( 'r' ) )
|
|
// InternalRDL.g:1887:3: ( 'r' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getREnumLiteralDeclaration_5());
|
|
}
|
|
// InternalRDL.g:1888:3: ( 'r' )
|
|
// InternalRDL.g:1888:4: 'r'
|
|
{
|
|
match(input,102,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getREnumLiteralDeclaration_5());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 7 :
|
|
// InternalRDL.g:1892:2: ( ( 'w' ) )
|
|
{
|
|
// InternalRDL.g:1892:2: ( ( 'w' ) )
|
|
// InternalRDL.g:1893:3: ( 'w' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getWEnumLiteralDeclaration_6());
|
|
}
|
|
// InternalRDL.g:1894:3: ( 'w' )
|
|
// InternalRDL.g:1894:4: 'w'
|
|
{
|
|
match(input,103,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getWEnumLiteralDeclaration_6());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 8 :
|
|
// InternalRDL.g:1898:2: ( ( 'na' ) )
|
|
{
|
|
// InternalRDL.g:1898:2: ( ( 'na' ) )
|
|
// InternalRDL.g:1899:3: ( 'na' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getNAEnumLiteralDeclaration_7());
|
|
}
|
|
// InternalRDL.g:1900:3: ( 'na' )
|
|
// InternalRDL.g:1900:4: 'na'
|
|
{
|
|
match(input,104,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getNAEnumLiteralDeclaration_7());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 9 :
|
|
// InternalRDL.g:1904:2: ( ( 'compact' ) )
|
|
{
|
|
// InternalRDL.g:1904:2: ( ( 'compact' ) )
|
|
// InternalRDL.g:1905:3: ( 'compact' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getCOMPACTEnumLiteralDeclaration_8());
|
|
}
|
|
// InternalRDL.g:1906:3: ( 'compact' )
|
|
// InternalRDL.g:1906:4: 'compact'
|
|
{
|
|
match(input,105,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getCOMPACTEnumLiteralDeclaration_8());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 10 :
|
|
// InternalRDL.g:1910:2: ( ( 'regalign' ) )
|
|
{
|
|
// InternalRDL.g:1910:2: ( ( 'regalign' ) )
|
|
// InternalRDL.g:1911:3: ( 'regalign' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getREGALIGNEnumLiteralDeclaration_9());
|
|
}
|
|
// InternalRDL.g:1912:3: ( 'regalign' )
|
|
// InternalRDL.g:1912:4: 'regalign'
|
|
{
|
|
match(input,106,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getREGALIGNEnumLiteralDeclaration_9());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 11 :
|
|
// InternalRDL.g:1916:2: ( ( 'fullalign' ) )
|
|
{
|
|
// InternalRDL.g:1916:2: ( ( 'fullalign' ) )
|
|
// InternalRDL.g:1917:3: ( 'fullalign' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getFULLALIGNEnumLiteralDeclaration_10());
|
|
}
|
|
// InternalRDL.g:1918:3: ( 'fullalign' )
|
|
// InternalRDL.g:1918:4: 'fullalign'
|
|
{
|
|
match(input,107,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getFULLALIGNEnumLiteralDeclaration_10());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 12 :
|
|
// InternalRDL.g:1922:2: ( ( 'hw' ) )
|
|
{
|
|
// InternalRDL.g:1922:2: ( ( 'hw' ) )
|
|
// InternalRDL.g:1923:3: ( 'hw' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getHWEnumLiteralDeclaration_11());
|
|
}
|
|
// InternalRDL.g:1924:3: ( 'hw' )
|
|
// InternalRDL.g:1924:4: 'hw'
|
|
{
|
|
match(input,83,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getHWEnumLiteralDeclaration_11());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 13 :
|
|
// InternalRDL.g:1928:2: ( ( 'sw' ) )
|
|
{
|
|
// InternalRDL.g:1928:2: ( ( 'sw' ) )
|
|
// InternalRDL.g:1929:3: ( 'sw' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRValueConstantAccess().getSWEnumLiteralDeclaration_12());
|
|
}
|
|
// InternalRDL.g:1930:3: ( 'sw' )
|
|
// InternalRDL.g:1930:4: 'sw'
|
|
{
|
|
match(input,82,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRValueConstantAccess().getSWEnumLiteralDeclaration_12());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__RValueConstant__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyModifier__Alternatives"
|
|
// InternalRDL.g:1938:1: rule__PropertyModifier__Alternatives : ( ( ( 'UNDEFINED' ) ) | ( ( 'posedge' ) ) | ( ( 'negedge' ) ) | ( ( 'bothedge' ) ) | ( ( 'level' ) ) | ( ( 'nonsticky' ) ) );
|
|
public final void rule__PropertyModifier__Alternatives() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1942:1: ( ( ( 'UNDEFINED' ) ) | ( ( 'posedge' ) ) | ( ( 'negedge' ) ) | ( ( 'bothedge' ) ) | ( ( 'level' ) ) | ( ( 'nonsticky' ) ) )
|
|
int alt26=6;
|
|
switch ( input.LA(1) ) {
|
|
case 97:
|
|
{
|
|
alt26=1;
|
|
}
|
|
break;
|
|
case 108:
|
|
{
|
|
alt26=2;
|
|
}
|
|
break;
|
|
case 109:
|
|
{
|
|
alt26=3;
|
|
}
|
|
break;
|
|
case 110:
|
|
{
|
|
alt26=4;
|
|
}
|
|
break;
|
|
case 111:
|
|
{
|
|
alt26=5;
|
|
}
|
|
break;
|
|
case 112:
|
|
{
|
|
alt26=6;
|
|
}
|
|
break;
|
|
default:
|
|
if (state.backtracking>0) {state.failed=true; return ;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 26, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt26) {
|
|
case 1 :
|
|
// InternalRDL.g:1943:2: ( ( 'UNDEFINED' ) )
|
|
{
|
|
// InternalRDL.g:1943:2: ( ( 'UNDEFINED' ) )
|
|
// InternalRDL.g:1944:3: ( 'UNDEFINED' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyModifierAccess().getUNDEFINEDEnumLiteralDeclaration_0());
|
|
}
|
|
// InternalRDL.g:1945:3: ( 'UNDEFINED' )
|
|
// InternalRDL.g:1945:4: 'UNDEFINED'
|
|
{
|
|
match(input,97,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyModifierAccess().getUNDEFINEDEnumLiteralDeclaration_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1949:2: ( ( 'posedge' ) )
|
|
{
|
|
// InternalRDL.g:1949:2: ( ( 'posedge' ) )
|
|
// InternalRDL.g:1950:3: ( 'posedge' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyModifierAccess().getPOSEDGEEnumLiteralDeclaration_1());
|
|
}
|
|
// InternalRDL.g:1951:3: ( 'posedge' )
|
|
// InternalRDL.g:1951:4: 'posedge'
|
|
{
|
|
match(input,108,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyModifierAccess().getPOSEDGEEnumLiteralDeclaration_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:1955:2: ( ( 'negedge' ) )
|
|
{
|
|
// InternalRDL.g:1955:2: ( ( 'negedge' ) )
|
|
// InternalRDL.g:1956:3: ( 'negedge' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyModifierAccess().getNEGEDGEEnumLiteralDeclaration_2());
|
|
}
|
|
// InternalRDL.g:1957:3: ( 'negedge' )
|
|
// InternalRDL.g:1957:4: 'negedge'
|
|
{
|
|
match(input,109,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyModifierAccess().getNEGEDGEEnumLiteralDeclaration_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:1961:2: ( ( 'bothedge' ) )
|
|
{
|
|
// InternalRDL.g:1961:2: ( ( 'bothedge' ) )
|
|
// InternalRDL.g:1962:3: ( 'bothedge' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyModifierAccess().getBOTHEDGEEnumLiteralDeclaration_3());
|
|
}
|
|
// InternalRDL.g:1963:3: ( 'bothedge' )
|
|
// InternalRDL.g:1963:4: 'bothedge'
|
|
{
|
|
match(input,110,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyModifierAccess().getBOTHEDGEEnumLiteralDeclaration_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 5 :
|
|
// InternalRDL.g:1967:2: ( ( 'level' ) )
|
|
{
|
|
// InternalRDL.g:1967:2: ( ( 'level' ) )
|
|
// InternalRDL.g:1968:3: ( 'level' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyModifierAccess().getLEVELEnumLiteralDeclaration_4());
|
|
}
|
|
// InternalRDL.g:1969:3: ( 'level' )
|
|
// InternalRDL.g:1969:4: 'level'
|
|
{
|
|
match(input,111,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyModifierAccess().getLEVELEnumLiteralDeclaration_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case 6 :
|
|
// InternalRDL.g:1973:2: ( ( 'nonsticky' ) )
|
|
{
|
|
// InternalRDL.g:1973:2: ( ( 'nonsticky' ) )
|
|
// InternalRDL.g:1974:3: ( 'nonsticky' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyModifierAccess().getNONSTICKYEnumLiteralDeclaration_5());
|
|
}
|
|
// InternalRDL.g:1975:3: ( 'nonsticky' )
|
|
// InternalRDL.g:1975:4: 'nonsticky'
|
|
{
|
|
match(input,112,FOLLOW_2); if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyModifierAccess().getNONSTICKYEnumLiteralDeclaration_5());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyModifier__Alternatives"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_1__0"
|
|
// InternalRDL.g:1983:1: rule__Root__Group_1__0 : rule__Root__Group_1__0__Impl rule__Root__Group_1__1 ;
|
|
public final void rule__Root__Group_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1987:1: ( rule__Root__Group_1__0__Impl rule__Root__Group_1__1 )
|
|
// InternalRDL.g:1988:2: rule__Root__Group_1__0__Impl rule__Root__Group_1__1
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__Root__Group_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_1__0__Impl"
|
|
// InternalRDL.g:1995:1: rule__Root__Group_1__0__Impl : ( ( rule__Root__ComponentDefinitionsAssignment_1_0 ) ) ;
|
|
public final void rule__Root__Group_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:1999:1: ( ( ( rule__Root__ComponentDefinitionsAssignment_1_0 ) ) )
|
|
// InternalRDL.g:2000:1: ( ( rule__Root__ComponentDefinitionsAssignment_1_0 ) )
|
|
{
|
|
// InternalRDL.g:2000:1: ( ( rule__Root__ComponentDefinitionsAssignment_1_0 ) )
|
|
// InternalRDL.g:2001:2: ( rule__Root__ComponentDefinitionsAssignment_1_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getComponentDefinitionsAssignment_1_0());
|
|
}
|
|
// InternalRDL.g:2002:2: ( rule__Root__ComponentDefinitionsAssignment_1_0 )
|
|
// InternalRDL.g:2002:3: rule__Root__ComponentDefinitionsAssignment_1_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__ComponentDefinitionsAssignment_1_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getComponentDefinitionsAssignment_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_1__1"
|
|
// InternalRDL.g:2010:1: rule__Root__Group_1__1 : rule__Root__Group_1__1__Impl ;
|
|
public final void rule__Root__Group_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2014:1: ( rule__Root__Group_1__1__Impl )
|
|
// InternalRDL.g:2015:2: rule__Root__Group_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__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__Root__Group_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_1__1__Impl"
|
|
// InternalRDL.g:2021:1: rule__Root__Group_1__1__Impl : ( ';' ) ;
|
|
public final void rule__Root__Group_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2025:1: ( ( ';' ) )
|
|
// InternalRDL.g:2026:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:2026:1: ( ';' )
|
|
// InternalRDL.g:2027:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getSemicolonKeyword_1_1());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getSemicolonKeyword_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_2__0"
|
|
// InternalRDL.g:2037:1: rule__Root__Group_2__0 : rule__Root__Group_2__0__Impl rule__Root__Group_2__1 ;
|
|
public final void rule__Root__Group_2__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2041:1: ( rule__Root__Group_2__0__Impl rule__Root__Group_2__1 )
|
|
// InternalRDL.g:2042:2: rule__Root__Group_2__0__Impl rule__Root__Group_2__1
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__Root__Group_2__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_2__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_2__0"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_2__0__Impl"
|
|
// InternalRDL.g:2049:1: rule__Root__Group_2__0__Impl : ( ( rule__Root__EnumDefinitionsAssignment_2_0 ) ) ;
|
|
public final void rule__Root__Group_2__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2053:1: ( ( ( rule__Root__EnumDefinitionsAssignment_2_0 ) ) )
|
|
// InternalRDL.g:2054:1: ( ( rule__Root__EnumDefinitionsAssignment_2_0 ) )
|
|
{
|
|
// InternalRDL.g:2054:1: ( ( rule__Root__EnumDefinitionsAssignment_2_0 ) )
|
|
// InternalRDL.g:2055:2: ( rule__Root__EnumDefinitionsAssignment_2_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getEnumDefinitionsAssignment_2_0());
|
|
}
|
|
// InternalRDL.g:2056:2: ( rule__Root__EnumDefinitionsAssignment_2_0 )
|
|
// InternalRDL.g:2056:3: rule__Root__EnumDefinitionsAssignment_2_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__EnumDefinitionsAssignment_2_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getEnumDefinitionsAssignment_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_2__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_2__1"
|
|
// InternalRDL.g:2064:1: rule__Root__Group_2__1 : rule__Root__Group_2__1__Impl ;
|
|
public final void rule__Root__Group_2__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2068:1: ( rule__Root__Group_2__1__Impl )
|
|
// InternalRDL.g:2069:2: rule__Root__Group_2__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__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__Root__Group_2__1"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_2__1__Impl"
|
|
// InternalRDL.g:2075:1: rule__Root__Group_2__1__Impl : ( ';' ) ;
|
|
public final void rule__Root__Group_2__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2079:1: ( ( ';' ) )
|
|
// InternalRDL.g:2080:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:2080:1: ( ';' )
|
|
// InternalRDL.g:2081:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getSemicolonKeyword_2_1());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getSemicolonKeyword_2_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_2__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_3__0"
|
|
// InternalRDL.g:2091:1: rule__Root__Group_3__0 : rule__Root__Group_3__0__Impl rule__Root__Group_3__1 ;
|
|
public final void rule__Root__Group_3__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2095:1: ( rule__Root__Group_3__0__Impl rule__Root__Group_3__1 )
|
|
// InternalRDL.g:2096:2: rule__Root__Group_3__0__Impl rule__Root__Group_3__1
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__Root__Group_3__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_3__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_3__0"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_3__0__Impl"
|
|
// InternalRDL.g:2103:1: rule__Root__Group_3__0__Impl : ( ( rule__Root__InstantiationsAssignment_3_0 ) ) ;
|
|
public final void rule__Root__Group_3__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2107:1: ( ( ( rule__Root__InstantiationsAssignment_3_0 ) ) )
|
|
// InternalRDL.g:2108:1: ( ( rule__Root__InstantiationsAssignment_3_0 ) )
|
|
{
|
|
// InternalRDL.g:2108:1: ( ( rule__Root__InstantiationsAssignment_3_0 ) )
|
|
// InternalRDL.g:2109:2: ( rule__Root__InstantiationsAssignment_3_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getInstantiationsAssignment_3_0());
|
|
}
|
|
// InternalRDL.g:2110:2: ( rule__Root__InstantiationsAssignment_3_0 )
|
|
// InternalRDL.g:2110:3: rule__Root__InstantiationsAssignment_3_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__InstantiationsAssignment_3_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getInstantiationsAssignment_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_3__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_3__1"
|
|
// InternalRDL.g:2118:1: rule__Root__Group_3__1 : rule__Root__Group_3__1__Impl ;
|
|
public final void rule__Root__Group_3__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2122:1: ( rule__Root__Group_3__1__Impl )
|
|
// InternalRDL.g:2123:2: rule__Root__Group_3__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_3__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_3__1"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_3__1__Impl"
|
|
// InternalRDL.g:2129:1: rule__Root__Group_3__1__Impl : ( ';' ) ;
|
|
public final void rule__Root__Group_3__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2133:1: ( ( ';' ) )
|
|
// InternalRDL.g:2134:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:2134:1: ( ';' )
|
|
// InternalRDL.g:2135:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getSemicolonKeyword_3_1());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getSemicolonKeyword_3_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_3__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_4__0"
|
|
// InternalRDL.g:2145:1: rule__Root__Group_4__0 : rule__Root__Group_4__0__Impl rule__Root__Group_4__1 ;
|
|
public final void rule__Root__Group_4__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2149:1: ( rule__Root__Group_4__0__Impl rule__Root__Group_4__1 )
|
|
// InternalRDL.g:2150:2: rule__Root__Group_4__0__Impl rule__Root__Group_4__1
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__Root__Group_4__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_4__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_4__0"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_4__0__Impl"
|
|
// InternalRDL.g:2157:1: rule__Root__Group_4__0__Impl : ( ( rule__Root__PropertyAssignmentsAssignment_4_0 ) ) ;
|
|
public final void rule__Root__Group_4__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2161:1: ( ( ( rule__Root__PropertyAssignmentsAssignment_4_0 ) ) )
|
|
// InternalRDL.g:2162:1: ( ( rule__Root__PropertyAssignmentsAssignment_4_0 ) )
|
|
{
|
|
// InternalRDL.g:2162:1: ( ( rule__Root__PropertyAssignmentsAssignment_4_0 ) )
|
|
// InternalRDL.g:2163:2: ( rule__Root__PropertyAssignmentsAssignment_4_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getPropertyAssignmentsAssignment_4_0());
|
|
}
|
|
// InternalRDL.g:2164:2: ( rule__Root__PropertyAssignmentsAssignment_4_0 )
|
|
// InternalRDL.g:2164:3: rule__Root__PropertyAssignmentsAssignment_4_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__PropertyAssignmentsAssignment_4_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getPropertyAssignmentsAssignment_4_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_4__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_4__1"
|
|
// InternalRDL.g:2172:1: rule__Root__Group_4__1 : rule__Root__Group_4__1__Impl ;
|
|
public final void rule__Root__Group_4__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2176:1: ( rule__Root__Group_4__1__Impl )
|
|
// InternalRDL.g:2177:2: rule__Root__Group_4__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__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__Root__Group_4__1"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_4__1__Impl"
|
|
// InternalRDL.g:2183:1: rule__Root__Group_4__1__Impl : ( ';' ) ;
|
|
public final void rule__Root__Group_4__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2187:1: ( ( ';' ) )
|
|
// InternalRDL.g:2188:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:2188:1: ( ';' )
|
|
// InternalRDL.g:2189:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getSemicolonKeyword_4_1());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getSemicolonKeyword_4_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_4__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_5__0"
|
|
// InternalRDL.g:2199:1: rule__Root__Group_5__0 : rule__Root__Group_5__0__Impl rule__Root__Group_5__1 ;
|
|
public final void rule__Root__Group_5__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2203:1: ( rule__Root__Group_5__0__Impl rule__Root__Group_5__1 )
|
|
// InternalRDL.g:2204:2: rule__Root__Group_5__0__Impl rule__Root__Group_5__1
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__Root__Group_5__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_5__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_5__0"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_5__0__Impl"
|
|
// InternalRDL.g:2211:1: rule__Root__Group_5__0__Impl : ( ( rule__Root__PropertyDefinitionsAssignment_5_0 ) ) ;
|
|
public final void rule__Root__Group_5__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2215:1: ( ( ( rule__Root__PropertyDefinitionsAssignment_5_0 ) ) )
|
|
// InternalRDL.g:2216:1: ( ( rule__Root__PropertyDefinitionsAssignment_5_0 ) )
|
|
{
|
|
// InternalRDL.g:2216:1: ( ( rule__Root__PropertyDefinitionsAssignment_5_0 ) )
|
|
// InternalRDL.g:2217:2: ( rule__Root__PropertyDefinitionsAssignment_5_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getPropertyDefinitionsAssignment_5_0());
|
|
}
|
|
// InternalRDL.g:2218:2: ( rule__Root__PropertyDefinitionsAssignment_5_0 )
|
|
// InternalRDL.g:2218:3: rule__Root__PropertyDefinitionsAssignment_5_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__PropertyDefinitionsAssignment_5_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getPropertyDefinitionsAssignment_5_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_5__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_5__1"
|
|
// InternalRDL.g:2226:1: rule__Root__Group_5__1 : rule__Root__Group_5__1__Impl ;
|
|
public final void rule__Root__Group_5__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2230:1: ( rule__Root__Group_5__1__Impl )
|
|
// InternalRDL.g:2231:2: rule__Root__Group_5__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_5__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_5__1"
|
|
|
|
|
|
// $ANTLR start "rule__Root__Group_5__1__Impl"
|
|
// InternalRDL.g:2237:1: rule__Root__Group_5__1__Impl : ( ';' ) ;
|
|
public final void rule__Root__Group_5__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2241:1: ( ( ';' ) )
|
|
// InternalRDL.g:2242:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:2242:1: ( ';' )
|
|
// InternalRDL.g:2243:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getSemicolonKeyword_5_1());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getSemicolonKeyword_5_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__Group_5__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Include__Group__0"
|
|
// InternalRDL.g:2253:1: rule__Include__Group__0 : rule__Include__Group__0__Impl rule__Include__Group__1 ;
|
|
public final void rule__Include__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2257:1: ( rule__Include__Group__0__Impl rule__Include__Group__1 )
|
|
// InternalRDL.g:2258:2: rule__Include__Group__0__Impl rule__Include__Group__1
|
|
{
|
|
pushFollow(FOLLOW_5);
|
|
rule__Include__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Include__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Include__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__Include__Group__0__Impl"
|
|
// InternalRDL.g:2265:1: rule__Include__Group__0__Impl : ( '`include' ) ;
|
|
public final void rule__Include__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2269:1: ( ( '`include' ) )
|
|
// InternalRDL.g:2270:1: ( '`include' )
|
|
{
|
|
// InternalRDL.g:2270:1: ( '`include' )
|
|
// InternalRDL.g:2271:2: '`include'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getIncludeAccess().getIncludeKeyword_0());
|
|
}
|
|
match(input,114,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getIncludeAccess().getIncludeKeyword_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Include__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Include__Group__1"
|
|
// InternalRDL.g:2280:1: rule__Include__Group__1 : rule__Include__Group__1__Impl ;
|
|
public final void rule__Include__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2284:1: ( rule__Include__Group__1__Impl )
|
|
// InternalRDL.g:2285:2: rule__Include__Group__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Include__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Include__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__Include__Group__1__Impl"
|
|
// InternalRDL.g:2291:1: rule__Include__Group__1__Impl : ( ( rule__Include__ImportURIAssignment_1 ) ) ;
|
|
public final void rule__Include__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2295:1: ( ( ( rule__Include__ImportURIAssignment_1 ) ) )
|
|
// InternalRDL.g:2296:1: ( ( rule__Include__ImportURIAssignment_1 ) )
|
|
{
|
|
// InternalRDL.g:2296:1: ( ( rule__Include__ImportURIAssignment_1 ) )
|
|
// InternalRDL.g:2297:2: ( rule__Include__ImportURIAssignment_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getIncludeAccess().getImportURIAssignment_1());
|
|
}
|
|
// InternalRDL.g:2298:2: ( rule__Include__ImportURIAssignment_1 )
|
|
// InternalRDL.g:2298:3: rule__Include__ImportURIAssignment_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Include__ImportURIAssignment_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getIncludeAccess().getImportURIAssignment_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Include__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__0"
|
|
// InternalRDL.g:2307:1: rule__PropertyDefinition__Group__0 : rule__PropertyDefinition__Group__0__Impl rule__PropertyDefinition__Group__1 ;
|
|
public final void rule__PropertyDefinition__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2311:1: ( rule__PropertyDefinition__Group__0__Impl rule__PropertyDefinition__Group__1 )
|
|
// InternalRDL.g:2312:2: rule__PropertyDefinition__Group__0__Impl rule__PropertyDefinition__Group__1
|
|
{
|
|
pushFollow(FOLLOW_6);
|
|
rule__PropertyDefinition__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__0__Impl"
|
|
// InternalRDL.g:2319:1: rule__PropertyDefinition__Group__0__Impl : ( 'property' ) ;
|
|
public final void rule__PropertyDefinition__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2323:1: ( ( 'property' ) )
|
|
// InternalRDL.g:2324:1: ( 'property' )
|
|
{
|
|
// InternalRDL.g:2324:1: ( 'property' )
|
|
// InternalRDL.g:2325:2: 'property'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getPropertyKeyword_0());
|
|
}
|
|
match(input,115,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getPropertyKeyword_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__1"
|
|
// InternalRDL.g:2334:1: rule__PropertyDefinition__Group__1 : rule__PropertyDefinition__Group__1__Impl rule__PropertyDefinition__Group__2 ;
|
|
public final void rule__PropertyDefinition__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2338:1: ( rule__PropertyDefinition__Group__1__Impl rule__PropertyDefinition__Group__2 )
|
|
// InternalRDL.g:2339:2: rule__PropertyDefinition__Group__1__Impl rule__PropertyDefinition__Group__2
|
|
{
|
|
pushFollow(FOLLOW_7);
|
|
rule__PropertyDefinition__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__1__Impl"
|
|
// InternalRDL.g:2346:1: rule__PropertyDefinition__Group__1__Impl : ( ( rule__PropertyDefinition__NameAssignment_1 ) ) ;
|
|
public final void rule__PropertyDefinition__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2350:1: ( ( ( rule__PropertyDefinition__NameAssignment_1 ) ) )
|
|
// InternalRDL.g:2351:1: ( ( rule__PropertyDefinition__NameAssignment_1 ) )
|
|
{
|
|
// InternalRDL.g:2351:1: ( ( rule__PropertyDefinition__NameAssignment_1 ) )
|
|
// InternalRDL.g:2352:2: ( rule__PropertyDefinition__NameAssignment_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getNameAssignment_1());
|
|
}
|
|
// InternalRDL.g:2353:2: ( rule__PropertyDefinition__NameAssignment_1 )
|
|
// InternalRDL.g:2353:3: rule__PropertyDefinition__NameAssignment_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__NameAssignment_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getNameAssignment_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__2"
|
|
// InternalRDL.g:2361:1: rule__PropertyDefinition__Group__2 : rule__PropertyDefinition__Group__2__Impl rule__PropertyDefinition__Group__3 ;
|
|
public final void rule__PropertyDefinition__Group__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2365:1: ( rule__PropertyDefinition__Group__2__Impl rule__PropertyDefinition__Group__3 )
|
|
// InternalRDL.g:2366:2: rule__PropertyDefinition__Group__2__Impl rule__PropertyDefinition__Group__3
|
|
{
|
|
pushFollow(FOLLOW_8);
|
|
rule__PropertyDefinition__Group__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__2__Impl"
|
|
// InternalRDL.g:2373:1: rule__PropertyDefinition__Group__2__Impl : ( '{' ) ;
|
|
public final void rule__PropertyDefinition__Group__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2377:1: ( ( '{' ) )
|
|
// InternalRDL.g:2378:1: ( '{' )
|
|
{
|
|
// InternalRDL.g:2378:1: ( '{' )
|
|
// InternalRDL.g:2379:2: '{'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getLeftCurlyBracketKeyword_2());
|
|
}
|
|
match(input,116,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getLeftCurlyBracketKeyword_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__3"
|
|
// InternalRDL.g:2388:1: rule__PropertyDefinition__Group__3 : rule__PropertyDefinition__Group__3__Impl rule__PropertyDefinition__Group__4 ;
|
|
public final void rule__PropertyDefinition__Group__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2392:1: ( rule__PropertyDefinition__Group__3__Impl rule__PropertyDefinition__Group__4 )
|
|
// InternalRDL.g:2393:2: rule__PropertyDefinition__Group__3__Impl rule__PropertyDefinition__Group__4
|
|
{
|
|
pushFollow(FOLLOW_9);
|
|
rule__PropertyDefinition__Group__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group__4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__3__Impl"
|
|
// InternalRDL.g:2400:1: rule__PropertyDefinition__Group__3__Impl : ( ( rule__PropertyDefinition__Alternatives_3 ) ) ;
|
|
public final void rule__PropertyDefinition__Group__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2404:1: ( ( ( rule__PropertyDefinition__Alternatives_3 ) ) )
|
|
// InternalRDL.g:2405:1: ( ( rule__PropertyDefinition__Alternatives_3 ) )
|
|
{
|
|
// InternalRDL.g:2405:1: ( ( rule__PropertyDefinition__Alternatives_3 ) )
|
|
// InternalRDL.g:2406:2: ( rule__PropertyDefinition__Alternatives_3 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getAlternatives_3());
|
|
}
|
|
// InternalRDL.g:2407:2: ( rule__PropertyDefinition__Alternatives_3 )
|
|
// InternalRDL.g:2407:3: rule__PropertyDefinition__Alternatives_3
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Alternatives_3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getAlternatives_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__4"
|
|
// InternalRDL.g:2415:1: rule__PropertyDefinition__Group__4 : rule__PropertyDefinition__Group__4__Impl rule__PropertyDefinition__Group__5 ;
|
|
public final void rule__PropertyDefinition__Group__4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2419:1: ( rule__PropertyDefinition__Group__4__Impl rule__PropertyDefinition__Group__5 )
|
|
// InternalRDL.g:2420:2: rule__PropertyDefinition__Group__4__Impl rule__PropertyDefinition__Group__5
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__PropertyDefinition__Group__4__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group__5();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__4"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__4__Impl"
|
|
// InternalRDL.g:2427:1: rule__PropertyDefinition__Group__4__Impl : ( '}' ) ;
|
|
public final void rule__PropertyDefinition__Group__4__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2431:1: ( ( '}' ) )
|
|
// InternalRDL.g:2432:1: ( '}' )
|
|
{
|
|
// InternalRDL.g:2432:1: ( '}' )
|
|
// InternalRDL.g:2433:2: '}'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getRightCurlyBracketKeyword_4());
|
|
}
|
|
match(input,117,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getRightCurlyBracketKeyword_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__4__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__5"
|
|
// InternalRDL.g:2442:1: rule__PropertyDefinition__Group__5 : rule__PropertyDefinition__Group__5__Impl ;
|
|
public final void rule__PropertyDefinition__Group__5() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2446:1: ( rule__PropertyDefinition__Group__5__Impl )
|
|
// InternalRDL.g:2447:2: rule__PropertyDefinition__Group__5__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group__5__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__5"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group__5__Impl"
|
|
// InternalRDL.g:2453:1: rule__PropertyDefinition__Group__5__Impl : ( ';' ) ;
|
|
public final void rule__PropertyDefinition__Group__5__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2457:1: ( ( ';' ) )
|
|
// InternalRDL.g:2458:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:2458:1: ( ';' )
|
|
// InternalRDL.g:2459:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_5());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_5());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group__5__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0__0"
|
|
// InternalRDL.g:2469:1: rule__PropertyDefinition__Group_3_0__0 : rule__PropertyDefinition__Group_3_0__0__Impl rule__PropertyDefinition__Group_3_0__1 ;
|
|
public final void rule__PropertyDefinition__Group_3_0__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2473:1: ( rule__PropertyDefinition__Group_3_0__0__Impl rule__PropertyDefinition__Group_3_0__1 )
|
|
// InternalRDL.g:2474:2: rule__PropertyDefinition__Group_3_0__0__Impl rule__PropertyDefinition__Group_3_0__1
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__PropertyDefinition__Group_3_0__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0__0__Impl"
|
|
// InternalRDL.g:2481:1: rule__PropertyDefinition__Group_3_0__0__Impl : ( 'type' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_0__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2485:1: ( ( 'type' ) )
|
|
// InternalRDL.g:2486:1: ( 'type' )
|
|
{
|
|
// InternalRDL.g:2486:1: ( 'type' )
|
|
// InternalRDL.g:2487:2: 'type'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypeKeyword_3_0_0());
|
|
}
|
|
match(input,118,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypeKeyword_3_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0__1"
|
|
// InternalRDL.g:2496:1: rule__PropertyDefinition__Group_3_0__1 : rule__PropertyDefinition__Group_3_0__1__Impl rule__PropertyDefinition__Group_3_0__2 ;
|
|
public final void rule__PropertyDefinition__Group_3_0__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2500:1: ( rule__PropertyDefinition__Group_3_0__1__Impl rule__PropertyDefinition__Group_3_0__2 )
|
|
// InternalRDL.g:2501:2: rule__PropertyDefinition__Group_3_0__1__Impl rule__PropertyDefinition__Group_3_0__2
|
|
{
|
|
pushFollow(FOLLOW_11);
|
|
rule__PropertyDefinition__Group_3_0__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0__1__Impl"
|
|
// InternalRDL.g:2508:1: rule__PropertyDefinition__Group_3_0__1__Impl : ( '=' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_0__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2512:1: ( ( '=' ) )
|
|
// InternalRDL.g:2513:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:2513:1: ( '=' )
|
|
// InternalRDL.g:2514:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getEqualsSignKeyword_3_0_1());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getEqualsSignKeyword_3_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0__2"
|
|
// InternalRDL.g:2523:1: rule__PropertyDefinition__Group_3_0__2 : rule__PropertyDefinition__Group_3_0__2__Impl rule__PropertyDefinition__Group_3_0__3 ;
|
|
public final void rule__PropertyDefinition__Group_3_0__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2527:1: ( rule__PropertyDefinition__Group_3_0__2__Impl rule__PropertyDefinition__Group_3_0__3 )
|
|
// InternalRDL.g:2528:2: rule__PropertyDefinition__Group_3_0__2__Impl rule__PropertyDefinition__Group_3_0__3
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__PropertyDefinition__Group_3_0__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0__2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0__2__Impl"
|
|
// InternalRDL.g:2535:1: rule__PropertyDefinition__Group_3_0__2__Impl : ( ( rule__PropertyDefinition__TypeAssignment_3_0_2 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_0__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2539:1: ( ( ( rule__PropertyDefinition__TypeAssignment_3_0_2 ) ) )
|
|
// InternalRDL.g:2540:1: ( ( rule__PropertyDefinition__TypeAssignment_3_0_2 ) )
|
|
{
|
|
// InternalRDL.g:2540:1: ( ( rule__PropertyDefinition__TypeAssignment_3_0_2 ) )
|
|
// InternalRDL.g:2541:2: ( rule__PropertyDefinition__TypeAssignment_3_0_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypeAssignment_3_0_2());
|
|
}
|
|
// InternalRDL.g:2542:2: ( rule__PropertyDefinition__TypeAssignment_3_0_2 )
|
|
// InternalRDL.g:2542:3: rule__PropertyDefinition__TypeAssignment_3_0_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__TypeAssignment_3_0_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypeAssignment_3_0_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0__3"
|
|
// InternalRDL.g:2550:1: rule__PropertyDefinition__Group_3_0__3 : rule__PropertyDefinition__Group_3_0__3__Impl rule__PropertyDefinition__Group_3_0__4 ;
|
|
public final void rule__PropertyDefinition__Group_3_0__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2554:1: ( rule__PropertyDefinition__Group_3_0__3__Impl rule__PropertyDefinition__Group_3_0__4 )
|
|
// InternalRDL.g:2555:2: rule__PropertyDefinition__Group_3_0__3__Impl rule__PropertyDefinition__Group_3_0__4
|
|
{
|
|
pushFollow(FOLLOW_8);
|
|
rule__PropertyDefinition__Group_3_0__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0__4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0__3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0__3__Impl"
|
|
// InternalRDL.g:2562:1: rule__PropertyDefinition__Group_3_0__3__Impl : ( ';' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_0__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2566:1: ( ( ';' ) )
|
|
// InternalRDL.g:2567:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:2567:1: ( ';' )
|
|
// InternalRDL.g:2568:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_3_0_3());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_3_0_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0__4"
|
|
// InternalRDL.g:2577:1: rule__PropertyDefinition__Group_3_0__4 : rule__PropertyDefinition__Group_3_0__4__Impl ;
|
|
public final void rule__PropertyDefinition__Group_3_0__4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2581:1: ( rule__PropertyDefinition__Group_3_0__4__Impl )
|
|
// InternalRDL.g:2582:2: rule__PropertyDefinition__Group_3_0__4__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0__4__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0__4"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0__4__Impl"
|
|
// InternalRDL.g:2588:1: rule__PropertyDefinition__Group_3_0__4__Impl : ( ( rule__PropertyDefinition__Alternatives_3_0_4 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_0__4__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2592:1: ( ( ( rule__PropertyDefinition__Alternatives_3_0_4 ) ) )
|
|
// InternalRDL.g:2593:1: ( ( rule__PropertyDefinition__Alternatives_3_0_4 ) )
|
|
{
|
|
// InternalRDL.g:2593:1: ( ( rule__PropertyDefinition__Alternatives_3_0_4 ) )
|
|
// InternalRDL.g:2594:2: ( rule__PropertyDefinition__Alternatives_3_0_4 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getAlternatives_3_0_4());
|
|
}
|
|
// InternalRDL.g:2595:2: ( rule__PropertyDefinition__Alternatives_3_0_4 )
|
|
// InternalRDL.g:2595:3: rule__PropertyDefinition__Alternatives_3_0_4
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Alternatives_3_0_4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getAlternatives_3_0_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0__4__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0_4_0__0"
|
|
// InternalRDL.g:2604:1: rule__PropertyDefinition__Group_3_0_4_0__0 : rule__PropertyDefinition__Group_3_0_4_0__0__Impl rule__PropertyDefinition__Group_3_0_4_0__1 ;
|
|
public final void rule__PropertyDefinition__Group_3_0_4_0__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2608:1: ( rule__PropertyDefinition__Group_3_0_4_0__0__Impl rule__PropertyDefinition__Group_3_0_4_0__1 )
|
|
// InternalRDL.g:2609:2: rule__PropertyDefinition__Group_3_0_4_0__0__Impl rule__PropertyDefinition__Group_3_0_4_0__1
|
|
{
|
|
pushFollow(FOLLOW_8);
|
|
rule__PropertyDefinition__Group_3_0_4_0__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0_4_0__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0_4_0__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0_4_0__0__Impl"
|
|
// InternalRDL.g:2616:1: rule__PropertyDefinition__Group_3_0_4_0__0__Impl : ( ( rule__PropertyDefinition__UsageAssignment_3_0_4_0_0 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_0_4_0__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2620:1: ( ( ( rule__PropertyDefinition__UsageAssignment_3_0_4_0_0 ) ) )
|
|
// InternalRDL.g:2621:1: ( ( rule__PropertyDefinition__UsageAssignment_3_0_4_0_0 ) )
|
|
{
|
|
// InternalRDL.g:2621:1: ( ( rule__PropertyDefinition__UsageAssignment_3_0_4_0_0 ) )
|
|
// InternalRDL.g:2622:2: ( rule__PropertyDefinition__UsageAssignment_3_0_4_0_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getUsageAssignment_3_0_4_0_0());
|
|
}
|
|
// InternalRDL.g:2623:2: ( rule__PropertyDefinition__UsageAssignment_3_0_4_0_0 )
|
|
// InternalRDL.g:2623:3: rule__PropertyDefinition__UsageAssignment_3_0_4_0_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__UsageAssignment_3_0_4_0_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getUsageAssignment_3_0_4_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0_4_0__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0_4_0__1"
|
|
// InternalRDL.g:2631:1: rule__PropertyDefinition__Group_3_0_4_0__1 : rule__PropertyDefinition__Group_3_0_4_0__1__Impl ;
|
|
public final void rule__PropertyDefinition__Group_3_0_4_0__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2635:1: ( rule__PropertyDefinition__Group_3_0_4_0__1__Impl )
|
|
// InternalRDL.g:2636:2: rule__PropertyDefinition__Group_3_0_4_0__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0_4_0__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0_4_0__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0_4_0__1__Impl"
|
|
// InternalRDL.g:2642:1: rule__PropertyDefinition__Group_3_0_4_0__1__Impl : ( ( rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1 )? ) ;
|
|
public final void rule__PropertyDefinition__Group_3_0_4_0__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2646:1: ( ( ( rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1 )? ) )
|
|
// InternalRDL.g:2647:1: ( ( rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1 )? )
|
|
{
|
|
// InternalRDL.g:2647:1: ( ( rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1 )? )
|
|
// InternalRDL.g:2648:2: ( rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getDefaultAssignment_3_0_4_0_1());
|
|
}
|
|
// InternalRDL.g:2649:2: ( rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1 )?
|
|
int alt27=2;
|
|
int LA27_0 = input.LA(1);
|
|
|
|
if ( (LA27_0==120) ) {
|
|
alt27=1;
|
|
}
|
|
switch (alt27) {
|
|
case 1 :
|
|
// InternalRDL.g:2649:3: rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getDefaultAssignment_3_0_4_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0_4_0__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0_4_1__0"
|
|
// InternalRDL.g:2658:1: rule__PropertyDefinition__Group_3_0_4_1__0 : rule__PropertyDefinition__Group_3_0_4_1__0__Impl rule__PropertyDefinition__Group_3_0_4_1__1 ;
|
|
public final void rule__PropertyDefinition__Group_3_0_4_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2662:1: ( rule__PropertyDefinition__Group_3_0_4_1__0__Impl rule__PropertyDefinition__Group_3_0_4_1__1 )
|
|
// InternalRDL.g:2663:2: rule__PropertyDefinition__Group_3_0_4_1__0__Impl rule__PropertyDefinition__Group_3_0_4_1__1
|
|
{
|
|
pushFollow(FOLLOW_12);
|
|
rule__PropertyDefinition__Group_3_0_4_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0_4_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0_4_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0_4_1__0__Impl"
|
|
// InternalRDL.g:2670:1: rule__PropertyDefinition__Group_3_0_4_1__0__Impl : ( ( rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_0_4_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2674:1: ( ( ( rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0 ) ) )
|
|
// InternalRDL.g:2675:1: ( ( rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0 ) )
|
|
{
|
|
// InternalRDL.g:2675:1: ( ( rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0 ) )
|
|
// InternalRDL.g:2676:2: ( rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getDefaultAssignment_3_0_4_1_0());
|
|
}
|
|
// InternalRDL.g:2677:2: ( rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0 )
|
|
// InternalRDL.g:2677:3: rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getDefaultAssignment_3_0_4_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0_4_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0_4_1__1"
|
|
// InternalRDL.g:2685:1: rule__PropertyDefinition__Group_3_0_4_1__1 : rule__PropertyDefinition__Group_3_0_4_1__1__Impl ;
|
|
public final void rule__PropertyDefinition__Group_3_0_4_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2689:1: ( rule__PropertyDefinition__Group_3_0_4_1__1__Impl )
|
|
// InternalRDL.g:2690:2: rule__PropertyDefinition__Group_3_0_4_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_0_4_1__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0_4_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_0_4_1__1__Impl"
|
|
// InternalRDL.g:2696:1: rule__PropertyDefinition__Group_3_0_4_1__1__Impl : ( ( rule__PropertyDefinition__UsageAssignment_3_0_4_1_1 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_0_4_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2700:1: ( ( ( rule__PropertyDefinition__UsageAssignment_3_0_4_1_1 ) ) )
|
|
// InternalRDL.g:2701:1: ( ( rule__PropertyDefinition__UsageAssignment_3_0_4_1_1 ) )
|
|
{
|
|
// InternalRDL.g:2701:1: ( ( rule__PropertyDefinition__UsageAssignment_3_0_4_1_1 ) )
|
|
// InternalRDL.g:2702:2: ( rule__PropertyDefinition__UsageAssignment_3_0_4_1_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getUsageAssignment_3_0_4_1_1());
|
|
}
|
|
// InternalRDL.g:2703:2: ( rule__PropertyDefinition__UsageAssignment_3_0_4_1_1 )
|
|
// InternalRDL.g:2703:3: rule__PropertyDefinition__UsageAssignment_3_0_4_1_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__UsageAssignment_3_0_4_1_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getUsageAssignment_3_0_4_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_0_4_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1__0"
|
|
// InternalRDL.g:2712:1: rule__PropertyDefinition__Group_3_1__0 : rule__PropertyDefinition__Group_3_1__0__Impl rule__PropertyDefinition__Group_3_1__1 ;
|
|
public final void rule__PropertyDefinition__Group_3_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2716:1: ( rule__PropertyDefinition__Group_3_1__0__Impl rule__PropertyDefinition__Group_3_1__1 )
|
|
// InternalRDL.g:2717:2: rule__PropertyDefinition__Group_3_1__0__Impl rule__PropertyDefinition__Group_3_1__1
|
|
{
|
|
pushFollow(FOLLOW_8);
|
|
rule__PropertyDefinition__Group_3_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1__0__Impl"
|
|
// InternalRDL.g:2724:1: rule__PropertyDefinition__Group_3_1__0__Impl : ( ( rule__PropertyDefinition__UsageAssignment_3_1_0 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2728:1: ( ( ( rule__PropertyDefinition__UsageAssignment_3_1_0 ) ) )
|
|
// InternalRDL.g:2729:1: ( ( rule__PropertyDefinition__UsageAssignment_3_1_0 ) )
|
|
{
|
|
// InternalRDL.g:2729:1: ( ( rule__PropertyDefinition__UsageAssignment_3_1_0 ) )
|
|
// InternalRDL.g:2730:2: ( rule__PropertyDefinition__UsageAssignment_3_1_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getUsageAssignment_3_1_0());
|
|
}
|
|
// InternalRDL.g:2731:2: ( rule__PropertyDefinition__UsageAssignment_3_1_0 )
|
|
// InternalRDL.g:2731:3: rule__PropertyDefinition__UsageAssignment_3_1_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__UsageAssignment_3_1_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getUsageAssignment_3_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1__1"
|
|
// InternalRDL.g:2739:1: rule__PropertyDefinition__Group_3_1__1 : rule__PropertyDefinition__Group_3_1__1__Impl ;
|
|
public final void rule__PropertyDefinition__Group_3_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2743:1: ( rule__PropertyDefinition__Group_3_1__1__Impl )
|
|
// InternalRDL.g:2744:2: rule__PropertyDefinition__Group_3_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1__1__Impl"
|
|
// InternalRDL.g:2750:1: rule__PropertyDefinition__Group_3_1__1__Impl : ( ( rule__PropertyDefinition__Alternatives_3_1_1 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2754:1: ( ( ( rule__PropertyDefinition__Alternatives_3_1_1 ) ) )
|
|
// InternalRDL.g:2755:1: ( ( rule__PropertyDefinition__Alternatives_3_1_1 ) )
|
|
{
|
|
// InternalRDL.g:2755:1: ( ( rule__PropertyDefinition__Alternatives_3_1_1 ) )
|
|
// InternalRDL.g:2756:2: ( rule__PropertyDefinition__Alternatives_3_1_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getAlternatives_3_1_1());
|
|
}
|
|
// InternalRDL.g:2757:2: ( rule__PropertyDefinition__Alternatives_3_1_1 )
|
|
// InternalRDL.g:2757:3: rule__PropertyDefinition__Alternatives_3_1_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Alternatives_3_1_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getAlternatives_3_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_0__0"
|
|
// InternalRDL.g:2766:1: rule__PropertyDefinition__Group_3_1_1_0__0 : rule__PropertyDefinition__Group_3_1_1_0__0__Impl rule__PropertyDefinition__Group_3_1_1_0__1 ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_0__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2770:1: ( rule__PropertyDefinition__Group_3_1_1_0__0__Impl rule__PropertyDefinition__Group_3_1_1_0__1 )
|
|
// InternalRDL.g:2771:2: rule__PropertyDefinition__Group_3_1_1_0__0__Impl rule__PropertyDefinition__Group_3_1_1_0__1
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__PropertyDefinition__Group_3_1_1_0__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_0__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_0__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_0__0__Impl"
|
|
// InternalRDL.g:2778:1: rule__PropertyDefinition__Group_3_1_1_0__0__Impl : ( 'type' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_0__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2782:1: ( ( 'type' ) )
|
|
// InternalRDL.g:2783:1: ( 'type' )
|
|
{
|
|
// InternalRDL.g:2783:1: ( 'type' )
|
|
// InternalRDL.g:2784:2: 'type'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypeKeyword_3_1_1_0_0());
|
|
}
|
|
match(input,118,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypeKeyword_3_1_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_0__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_0__1"
|
|
// InternalRDL.g:2793:1: rule__PropertyDefinition__Group_3_1_1_0__1 : rule__PropertyDefinition__Group_3_1_1_0__1__Impl rule__PropertyDefinition__Group_3_1_1_0__2 ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_0__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2797:1: ( rule__PropertyDefinition__Group_3_1_1_0__1__Impl rule__PropertyDefinition__Group_3_1_1_0__2 )
|
|
// InternalRDL.g:2798:2: rule__PropertyDefinition__Group_3_1_1_0__1__Impl rule__PropertyDefinition__Group_3_1_1_0__2
|
|
{
|
|
pushFollow(FOLLOW_11);
|
|
rule__PropertyDefinition__Group_3_1_1_0__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_0__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_0__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_0__1__Impl"
|
|
// InternalRDL.g:2805:1: rule__PropertyDefinition__Group_3_1_1_0__1__Impl : ( '=' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_0__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2809:1: ( ( '=' ) )
|
|
// InternalRDL.g:2810:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:2810:1: ( '=' )
|
|
// InternalRDL.g:2811:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getEqualsSignKeyword_3_1_1_0_1());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getEqualsSignKeyword_3_1_1_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_0__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_0__2"
|
|
// InternalRDL.g:2820:1: rule__PropertyDefinition__Group_3_1_1_0__2 : rule__PropertyDefinition__Group_3_1_1_0__2__Impl rule__PropertyDefinition__Group_3_1_1_0__3 ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_0__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2824:1: ( rule__PropertyDefinition__Group_3_1_1_0__2__Impl rule__PropertyDefinition__Group_3_1_1_0__3 )
|
|
// InternalRDL.g:2825:2: rule__PropertyDefinition__Group_3_1_1_0__2__Impl rule__PropertyDefinition__Group_3_1_1_0__3
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__PropertyDefinition__Group_3_1_1_0__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_0__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_0__2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_0__2__Impl"
|
|
// InternalRDL.g:2832:1: rule__PropertyDefinition__Group_3_1_1_0__2__Impl : ( ( rule__PropertyDefinition__TypeAssignment_3_1_1_0_2 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_0__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2836:1: ( ( ( rule__PropertyDefinition__TypeAssignment_3_1_1_0_2 ) ) )
|
|
// InternalRDL.g:2837:1: ( ( rule__PropertyDefinition__TypeAssignment_3_1_1_0_2 ) )
|
|
{
|
|
// InternalRDL.g:2837:1: ( ( rule__PropertyDefinition__TypeAssignment_3_1_1_0_2 ) )
|
|
// InternalRDL.g:2838:2: ( rule__PropertyDefinition__TypeAssignment_3_1_1_0_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypeAssignment_3_1_1_0_2());
|
|
}
|
|
// InternalRDL.g:2839:2: ( rule__PropertyDefinition__TypeAssignment_3_1_1_0_2 )
|
|
// InternalRDL.g:2839:3: rule__PropertyDefinition__TypeAssignment_3_1_1_0_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__TypeAssignment_3_1_1_0_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypeAssignment_3_1_1_0_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_0__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_0__3"
|
|
// InternalRDL.g:2847:1: rule__PropertyDefinition__Group_3_1_1_0__3 : rule__PropertyDefinition__Group_3_1_1_0__3__Impl rule__PropertyDefinition__Group_3_1_1_0__4 ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_0__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2851:1: ( rule__PropertyDefinition__Group_3_1_1_0__3__Impl rule__PropertyDefinition__Group_3_1_1_0__4 )
|
|
// InternalRDL.g:2852:2: rule__PropertyDefinition__Group_3_1_1_0__3__Impl rule__PropertyDefinition__Group_3_1_1_0__4
|
|
{
|
|
pushFollow(FOLLOW_8);
|
|
rule__PropertyDefinition__Group_3_1_1_0__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_0__4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_0__3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_0__3__Impl"
|
|
// InternalRDL.g:2859:1: rule__PropertyDefinition__Group_3_1_1_0__3__Impl : ( ';' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_0__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2863:1: ( ( ';' ) )
|
|
// InternalRDL.g:2864:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:2864:1: ( ';' )
|
|
// InternalRDL.g:2865:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_3_1_1_0_3());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_3_1_1_0_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_0__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_0__4"
|
|
// InternalRDL.g:2874:1: rule__PropertyDefinition__Group_3_1_1_0__4 : rule__PropertyDefinition__Group_3_1_1_0__4__Impl ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_0__4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2878:1: ( rule__PropertyDefinition__Group_3_1_1_0__4__Impl )
|
|
// InternalRDL.g:2879:2: rule__PropertyDefinition__Group_3_1_1_0__4__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_0__4__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_0__4"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_0__4__Impl"
|
|
// InternalRDL.g:2885:1: rule__PropertyDefinition__Group_3_1_1_0__4__Impl : ( ( rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4 )? ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_0__4__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2889:1: ( ( ( rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4 )? ) )
|
|
// InternalRDL.g:2890:1: ( ( rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4 )? )
|
|
{
|
|
// InternalRDL.g:2890:1: ( ( rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4 )? )
|
|
// InternalRDL.g:2891:2: ( rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getDefaultAssignment_3_1_1_0_4());
|
|
}
|
|
// InternalRDL.g:2892:2: ( rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4 )?
|
|
int alt28=2;
|
|
int LA28_0 = input.LA(1);
|
|
|
|
if ( (LA28_0==120) ) {
|
|
alt28=1;
|
|
}
|
|
switch (alt28) {
|
|
case 1 :
|
|
// InternalRDL.g:2892:3: rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getDefaultAssignment_3_1_1_0_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_0__4__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_1__0"
|
|
// InternalRDL.g:2901:1: rule__PropertyDefinition__Group_3_1_1_1__0 : rule__PropertyDefinition__Group_3_1_1_1__0__Impl rule__PropertyDefinition__Group_3_1_1_1__1 ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2905:1: ( rule__PropertyDefinition__Group_3_1_1_1__0__Impl rule__PropertyDefinition__Group_3_1_1_1__1 )
|
|
// InternalRDL.g:2906:2: rule__PropertyDefinition__Group_3_1_1_1__0__Impl rule__PropertyDefinition__Group_3_1_1_1__1
|
|
{
|
|
pushFollow(FOLLOW_13);
|
|
rule__PropertyDefinition__Group_3_1_1_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_1__0__Impl"
|
|
// InternalRDL.g:2913:1: rule__PropertyDefinition__Group_3_1_1_1__0__Impl : ( ( rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2917:1: ( ( ( rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0 ) ) )
|
|
// InternalRDL.g:2918:1: ( ( rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0 ) )
|
|
{
|
|
// InternalRDL.g:2918:1: ( ( rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0 ) )
|
|
// InternalRDL.g:2919:2: ( rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getDefaultAssignment_3_1_1_1_0());
|
|
}
|
|
// InternalRDL.g:2920:2: ( rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0 )
|
|
// InternalRDL.g:2920:3: rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getDefaultAssignment_3_1_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_1__1"
|
|
// InternalRDL.g:2928:1: rule__PropertyDefinition__Group_3_1_1_1__1 : rule__PropertyDefinition__Group_3_1_1_1__1__Impl rule__PropertyDefinition__Group_3_1_1_1__2 ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2932:1: ( rule__PropertyDefinition__Group_3_1_1_1__1__Impl rule__PropertyDefinition__Group_3_1_1_1__2 )
|
|
// InternalRDL.g:2933:2: rule__PropertyDefinition__Group_3_1_1_1__1__Impl rule__PropertyDefinition__Group_3_1_1_1__2
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__PropertyDefinition__Group_3_1_1_1__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_1__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_1__1__Impl"
|
|
// InternalRDL.g:2940:1: rule__PropertyDefinition__Group_3_1_1_1__1__Impl : ( 'type' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2944:1: ( ( 'type' ) )
|
|
// InternalRDL.g:2945:1: ( 'type' )
|
|
{
|
|
// InternalRDL.g:2945:1: ( 'type' )
|
|
// InternalRDL.g:2946:2: 'type'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypeKeyword_3_1_1_1_1());
|
|
}
|
|
match(input,118,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypeKeyword_3_1_1_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_1__2"
|
|
// InternalRDL.g:2955:1: rule__PropertyDefinition__Group_3_1_1_1__2 : rule__PropertyDefinition__Group_3_1_1_1__2__Impl rule__PropertyDefinition__Group_3_1_1_1__3 ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_1__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2959:1: ( rule__PropertyDefinition__Group_3_1_1_1__2__Impl rule__PropertyDefinition__Group_3_1_1_1__3 )
|
|
// InternalRDL.g:2960:2: rule__PropertyDefinition__Group_3_1_1_1__2__Impl rule__PropertyDefinition__Group_3_1_1_1__3
|
|
{
|
|
pushFollow(FOLLOW_11);
|
|
rule__PropertyDefinition__Group_3_1_1_1__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_1__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_1__2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_1__2__Impl"
|
|
// InternalRDL.g:2967:1: rule__PropertyDefinition__Group_3_1_1_1__2__Impl : ( '=' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_1__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2971:1: ( ( '=' ) )
|
|
// InternalRDL.g:2972:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:2972:1: ( '=' )
|
|
// InternalRDL.g:2973:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getEqualsSignKeyword_3_1_1_1_2());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getEqualsSignKeyword_3_1_1_1_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_1__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_1__3"
|
|
// InternalRDL.g:2982:1: rule__PropertyDefinition__Group_3_1_1_1__3 : rule__PropertyDefinition__Group_3_1_1_1__3__Impl rule__PropertyDefinition__Group_3_1_1_1__4 ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_1__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2986:1: ( rule__PropertyDefinition__Group_3_1_1_1__3__Impl rule__PropertyDefinition__Group_3_1_1_1__4 )
|
|
// InternalRDL.g:2987:2: rule__PropertyDefinition__Group_3_1_1_1__3__Impl rule__PropertyDefinition__Group_3_1_1_1__4
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__PropertyDefinition__Group_3_1_1_1__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_1__4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_1__3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_1__3__Impl"
|
|
// InternalRDL.g:2994:1: rule__PropertyDefinition__Group_3_1_1_1__3__Impl : ( ( rule__PropertyDefinition__TypeAssignment_3_1_1_1_3 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_1__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:2998:1: ( ( ( rule__PropertyDefinition__TypeAssignment_3_1_1_1_3 ) ) )
|
|
// InternalRDL.g:2999:1: ( ( rule__PropertyDefinition__TypeAssignment_3_1_1_1_3 ) )
|
|
{
|
|
// InternalRDL.g:2999:1: ( ( rule__PropertyDefinition__TypeAssignment_3_1_1_1_3 ) )
|
|
// InternalRDL.g:3000:2: ( rule__PropertyDefinition__TypeAssignment_3_1_1_1_3 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypeAssignment_3_1_1_1_3());
|
|
}
|
|
// InternalRDL.g:3001:2: ( rule__PropertyDefinition__TypeAssignment_3_1_1_1_3 )
|
|
// InternalRDL.g:3001:3: rule__PropertyDefinition__TypeAssignment_3_1_1_1_3
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__TypeAssignment_3_1_1_1_3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypeAssignment_3_1_1_1_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_1__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_1__4"
|
|
// InternalRDL.g:3009:1: rule__PropertyDefinition__Group_3_1_1_1__4 : rule__PropertyDefinition__Group_3_1_1_1__4__Impl ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_1__4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3013:1: ( rule__PropertyDefinition__Group_3_1_1_1__4__Impl )
|
|
// InternalRDL.g:3014:2: rule__PropertyDefinition__Group_3_1_1_1__4__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_1_1_1__4__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_1__4"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_1_1_1__4__Impl"
|
|
// InternalRDL.g:3020:1: rule__PropertyDefinition__Group_3_1_1_1__4__Impl : ( ';' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_1_1_1__4__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3024:1: ( ( ';' ) )
|
|
// InternalRDL.g:3025:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:3025:1: ( ';' )
|
|
// InternalRDL.g:3026:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_3_1_1_1_4());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_3_1_1_1_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_1_1_1__4__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2__0"
|
|
// InternalRDL.g:3036:1: rule__PropertyDefinition__Group_3_2__0 : rule__PropertyDefinition__Group_3_2__0__Impl rule__PropertyDefinition__Group_3_2__1 ;
|
|
public final void rule__PropertyDefinition__Group_3_2__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3040:1: ( rule__PropertyDefinition__Group_3_2__0__Impl rule__PropertyDefinition__Group_3_2__1 )
|
|
// InternalRDL.g:3041:2: rule__PropertyDefinition__Group_3_2__0__Impl rule__PropertyDefinition__Group_3_2__1
|
|
{
|
|
pushFollow(FOLLOW_14);
|
|
rule__PropertyDefinition__Group_3_2__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2__0__Impl"
|
|
// InternalRDL.g:3048:1: rule__PropertyDefinition__Group_3_2__0__Impl : ( ( rule__PropertyDefinition__DefaultAssignment_3_2_0 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3052:1: ( ( ( rule__PropertyDefinition__DefaultAssignment_3_2_0 ) ) )
|
|
// InternalRDL.g:3053:1: ( ( rule__PropertyDefinition__DefaultAssignment_3_2_0 ) )
|
|
{
|
|
// InternalRDL.g:3053:1: ( ( rule__PropertyDefinition__DefaultAssignment_3_2_0 ) )
|
|
// InternalRDL.g:3054:2: ( rule__PropertyDefinition__DefaultAssignment_3_2_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getDefaultAssignment_3_2_0());
|
|
}
|
|
// InternalRDL.g:3055:2: ( rule__PropertyDefinition__DefaultAssignment_3_2_0 )
|
|
// InternalRDL.g:3055:3: rule__PropertyDefinition__DefaultAssignment_3_2_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__DefaultAssignment_3_2_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getDefaultAssignment_3_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2__1"
|
|
// InternalRDL.g:3063:1: rule__PropertyDefinition__Group_3_2__1 : rule__PropertyDefinition__Group_3_2__1__Impl ;
|
|
public final void rule__PropertyDefinition__Group_3_2__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3067:1: ( rule__PropertyDefinition__Group_3_2__1__Impl )
|
|
// InternalRDL.g:3068:2: rule__PropertyDefinition__Group_3_2__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2__1__Impl"
|
|
// InternalRDL.g:3074:1: rule__PropertyDefinition__Group_3_2__1__Impl : ( ( rule__PropertyDefinition__Alternatives_3_2_1 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3078:1: ( ( ( rule__PropertyDefinition__Alternatives_3_2_1 ) ) )
|
|
// InternalRDL.g:3079:1: ( ( rule__PropertyDefinition__Alternatives_3_2_1 ) )
|
|
{
|
|
// InternalRDL.g:3079:1: ( ( rule__PropertyDefinition__Alternatives_3_2_1 ) )
|
|
// InternalRDL.g:3080:2: ( rule__PropertyDefinition__Alternatives_3_2_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getAlternatives_3_2_1());
|
|
}
|
|
// InternalRDL.g:3081:2: ( rule__PropertyDefinition__Alternatives_3_2_1 )
|
|
// InternalRDL.g:3081:3: rule__PropertyDefinition__Alternatives_3_2_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Alternatives_3_2_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getAlternatives_3_2_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_0__0"
|
|
// InternalRDL.g:3090:1: rule__PropertyDefinition__Group_3_2_1_0__0 : rule__PropertyDefinition__Group_3_2_1_0__0__Impl rule__PropertyDefinition__Group_3_2_1_0__1 ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_0__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3094:1: ( rule__PropertyDefinition__Group_3_2_1_0__0__Impl rule__PropertyDefinition__Group_3_2_1_0__1 )
|
|
// InternalRDL.g:3095:2: rule__PropertyDefinition__Group_3_2_1_0__0__Impl rule__PropertyDefinition__Group_3_2_1_0__1
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__PropertyDefinition__Group_3_2_1_0__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_0__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_0__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_0__0__Impl"
|
|
// InternalRDL.g:3102:1: rule__PropertyDefinition__Group_3_2_1_0__0__Impl : ( 'type' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_0__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3106:1: ( ( 'type' ) )
|
|
// InternalRDL.g:3107:1: ( 'type' )
|
|
{
|
|
// InternalRDL.g:3107:1: ( 'type' )
|
|
// InternalRDL.g:3108:2: 'type'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypeKeyword_3_2_1_0_0());
|
|
}
|
|
match(input,118,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypeKeyword_3_2_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_0__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_0__1"
|
|
// InternalRDL.g:3117:1: rule__PropertyDefinition__Group_3_2_1_0__1 : rule__PropertyDefinition__Group_3_2_1_0__1__Impl rule__PropertyDefinition__Group_3_2_1_0__2 ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_0__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3121:1: ( rule__PropertyDefinition__Group_3_2_1_0__1__Impl rule__PropertyDefinition__Group_3_2_1_0__2 )
|
|
// InternalRDL.g:3122:2: rule__PropertyDefinition__Group_3_2_1_0__1__Impl rule__PropertyDefinition__Group_3_2_1_0__2
|
|
{
|
|
pushFollow(FOLLOW_11);
|
|
rule__PropertyDefinition__Group_3_2_1_0__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_0__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_0__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_0__1__Impl"
|
|
// InternalRDL.g:3129:1: rule__PropertyDefinition__Group_3_2_1_0__1__Impl : ( '=' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_0__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3133:1: ( ( '=' ) )
|
|
// InternalRDL.g:3134:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:3134:1: ( '=' )
|
|
// InternalRDL.g:3135:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getEqualsSignKeyword_3_2_1_0_1());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getEqualsSignKeyword_3_2_1_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_0__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_0__2"
|
|
// InternalRDL.g:3144:1: rule__PropertyDefinition__Group_3_2_1_0__2 : rule__PropertyDefinition__Group_3_2_1_0__2__Impl rule__PropertyDefinition__Group_3_2_1_0__3 ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_0__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3148:1: ( rule__PropertyDefinition__Group_3_2_1_0__2__Impl rule__PropertyDefinition__Group_3_2_1_0__3 )
|
|
// InternalRDL.g:3149:2: rule__PropertyDefinition__Group_3_2_1_0__2__Impl rule__PropertyDefinition__Group_3_2_1_0__3
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__PropertyDefinition__Group_3_2_1_0__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_0__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_0__2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_0__2__Impl"
|
|
// InternalRDL.g:3156:1: rule__PropertyDefinition__Group_3_2_1_0__2__Impl : ( ( rule__PropertyDefinition__TypeAssignment_3_2_1_0_2 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_0__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3160:1: ( ( ( rule__PropertyDefinition__TypeAssignment_3_2_1_0_2 ) ) )
|
|
// InternalRDL.g:3161:1: ( ( rule__PropertyDefinition__TypeAssignment_3_2_1_0_2 ) )
|
|
{
|
|
// InternalRDL.g:3161:1: ( ( rule__PropertyDefinition__TypeAssignment_3_2_1_0_2 ) )
|
|
// InternalRDL.g:3162:2: ( rule__PropertyDefinition__TypeAssignment_3_2_1_0_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypeAssignment_3_2_1_0_2());
|
|
}
|
|
// InternalRDL.g:3163:2: ( rule__PropertyDefinition__TypeAssignment_3_2_1_0_2 )
|
|
// InternalRDL.g:3163:3: rule__PropertyDefinition__TypeAssignment_3_2_1_0_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__TypeAssignment_3_2_1_0_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypeAssignment_3_2_1_0_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_0__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_0__3"
|
|
// InternalRDL.g:3171:1: rule__PropertyDefinition__Group_3_2_1_0__3 : rule__PropertyDefinition__Group_3_2_1_0__3__Impl rule__PropertyDefinition__Group_3_2_1_0__4 ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_0__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3175:1: ( rule__PropertyDefinition__Group_3_2_1_0__3__Impl rule__PropertyDefinition__Group_3_2_1_0__4 )
|
|
// InternalRDL.g:3176:2: rule__PropertyDefinition__Group_3_2_1_0__3__Impl rule__PropertyDefinition__Group_3_2_1_0__4
|
|
{
|
|
pushFollow(FOLLOW_12);
|
|
rule__PropertyDefinition__Group_3_2_1_0__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_0__4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_0__3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_0__3__Impl"
|
|
// InternalRDL.g:3183:1: rule__PropertyDefinition__Group_3_2_1_0__3__Impl : ( ';' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_0__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3187:1: ( ( ';' ) )
|
|
// InternalRDL.g:3188:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:3188:1: ( ';' )
|
|
// InternalRDL.g:3189:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_3_2_1_0_3());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_3_2_1_0_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_0__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_0__4"
|
|
// InternalRDL.g:3198:1: rule__PropertyDefinition__Group_3_2_1_0__4 : rule__PropertyDefinition__Group_3_2_1_0__4__Impl ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_0__4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3202:1: ( rule__PropertyDefinition__Group_3_2_1_0__4__Impl )
|
|
// InternalRDL.g:3203:2: rule__PropertyDefinition__Group_3_2_1_0__4__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_0__4__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_0__4"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_0__4__Impl"
|
|
// InternalRDL.g:3209:1: rule__PropertyDefinition__Group_3_2_1_0__4__Impl : ( ( rule__PropertyDefinition__UsageAssignment_3_2_1_0_4 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_0__4__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3213:1: ( ( ( rule__PropertyDefinition__UsageAssignment_3_2_1_0_4 ) ) )
|
|
// InternalRDL.g:3214:1: ( ( rule__PropertyDefinition__UsageAssignment_3_2_1_0_4 ) )
|
|
{
|
|
// InternalRDL.g:3214:1: ( ( rule__PropertyDefinition__UsageAssignment_3_2_1_0_4 ) )
|
|
// InternalRDL.g:3215:2: ( rule__PropertyDefinition__UsageAssignment_3_2_1_0_4 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getUsageAssignment_3_2_1_0_4());
|
|
}
|
|
// InternalRDL.g:3216:2: ( rule__PropertyDefinition__UsageAssignment_3_2_1_0_4 )
|
|
// InternalRDL.g:3216:3: rule__PropertyDefinition__UsageAssignment_3_2_1_0_4
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__UsageAssignment_3_2_1_0_4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getUsageAssignment_3_2_1_0_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_0__4__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_1__0"
|
|
// InternalRDL.g:3225:1: rule__PropertyDefinition__Group_3_2_1_1__0 : rule__PropertyDefinition__Group_3_2_1_1__0__Impl rule__PropertyDefinition__Group_3_2_1_1__1 ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3229:1: ( rule__PropertyDefinition__Group_3_2_1_1__0__Impl rule__PropertyDefinition__Group_3_2_1_1__1 )
|
|
// InternalRDL.g:3230:2: rule__PropertyDefinition__Group_3_2_1_1__0__Impl rule__PropertyDefinition__Group_3_2_1_1__1
|
|
{
|
|
pushFollow(FOLLOW_13);
|
|
rule__PropertyDefinition__Group_3_2_1_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_1__0__Impl"
|
|
// InternalRDL.g:3237:1: rule__PropertyDefinition__Group_3_2_1_1__0__Impl : ( ( rule__PropertyDefinition__UsageAssignment_3_2_1_1_0 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3241:1: ( ( ( rule__PropertyDefinition__UsageAssignment_3_2_1_1_0 ) ) )
|
|
// InternalRDL.g:3242:1: ( ( rule__PropertyDefinition__UsageAssignment_3_2_1_1_0 ) )
|
|
{
|
|
// InternalRDL.g:3242:1: ( ( rule__PropertyDefinition__UsageAssignment_3_2_1_1_0 ) )
|
|
// InternalRDL.g:3243:2: ( rule__PropertyDefinition__UsageAssignment_3_2_1_1_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getUsageAssignment_3_2_1_1_0());
|
|
}
|
|
// InternalRDL.g:3244:2: ( rule__PropertyDefinition__UsageAssignment_3_2_1_1_0 )
|
|
// InternalRDL.g:3244:3: rule__PropertyDefinition__UsageAssignment_3_2_1_1_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__UsageAssignment_3_2_1_1_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getUsageAssignment_3_2_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_1__1"
|
|
// InternalRDL.g:3252:1: rule__PropertyDefinition__Group_3_2_1_1__1 : rule__PropertyDefinition__Group_3_2_1_1__1__Impl rule__PropertyDefinition__Group_3_2_1_1__2 ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3256:1: ( rule__PropertyDefinition__Group_3_2_1_1__1__Impl rule__PropertyDefinition__Group_3_2_1_1__2 )
|
|
// InternalRDL.g:3257:2: rule__PropertyDefinition__Group_3_2_1_1__1__Impl rule__PropertyDefinition__Group_3_2_1_1__2
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__PropertyDefinition__Group_3_2_1_1__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_1__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_1__1__Impl"
|
|
// InternalRDL.g:3264:1: rule__PropertyDefinition__Group_3_2_1_1__1__Impl : ( 'type' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3268:1: ( ( 'type' ) )
|
|
// InternalRDL.g:3269:1: ( 'type' )
|
|
{
|
|
// InternalRDL.g:3269:1: ( 'type' )
|
|
// InternalRDL.g:3270:2: 'type'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypeKeyword_3_2_1_1_1());
|
|
}
|
|
match(input,118,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypeKeyword_3_2_1_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_1__2"
|
|
// InternalRDL.g:3279:1: rule__PropertyDefinition__Group_3_2_1_1__2 : rule__PropertyDefinition__Group_3_2_1_1__2__Impl rule__PropertyDefinition__Group_3_2_1_1__3 ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_1__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3283:1: ( rule__PropertyDefinition__Group_3_2_1_1__2__Impl rule__PropertyDefinition__Group_3_2_1_1__3 )
|
|
// InternalRDL.g:3284:2: rule__PropertyDefinition__Group_3_2_1_1__2__Impl rule__PropertyDefinition__Group_3_2_1_1__3
|
|
{
|
|
pushFollow(FOLLOW_11);
|
|
rule__PropertyDefinition__Group_3_2_1_1__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_1__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_1__2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_1__2__Impl"
|
|
// InternalRDL.g:3291:1: rule__PropertyDefinition__Group_3_2_1_1__2__Impl : ( '=' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_1__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3295:1: ( ( '=' ) )
|
|
// InternalRDL.g:3296:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:3296:1: ( '=' )
|
|
// InternalRDL.g:3297:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getEqualsSignKeyword_3_2_1_1_2());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getEqualsSignKeyword_3_2_1_1_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_1__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_1__3"
|
|
// InternalRDL.g:3306:1: rule__PropertyDefinition__Group_3_2_1_1__3 : rule__PropertyDefinition__Group_3_2_1_1__3__Impl rule__PropertyDefinition__Group_3_2_1_1__4 ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_1__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3310:1: ( rule__PropertyDefinition__Group_3_2_1_1__3__Impl rule__PropertyDefinition__Group_3_2_1_1__4 )
|
|
// InternalRDL.g:3311:2: rule__PropertyDefinition__Group_3_2_1_1__3__Impl rule__PropertyDefinition__Group_3_2_1_1__4
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__PropertyDefinition__Group_3_2_1_1__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_1__4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_1__3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_1__3__Impl"
|
|
// InternalRDL.g:3318:1: rule__PropertyDefinition__Group_3_2_1_1__3__Impl : ( ( rule__PropertyDefinition__TypeAssignment_3_2_1_1_3 ) ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_1__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3322:1: ( ( ( rule__PropertyDefinition__TypeAssignment_3_2_1_1_3 ) ) )
|
|
// InternalRDL.g:3323:1: ( ( rule__PropertyDefinition__TypeAssignment_3_2_1_1_3 ) )
|
|
{
|
|
// InternalRDL.g:3323:1: ( ( rule__PropertyDefinition__TypeAssignment_3_2_1_1_3 ) )
|
|
// InternalRDL.g:3324:2: ( rule__PropertyDefinition__TypeAssignment_3_2_1_1_3 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypeAssignment_3_2_1_1_3());
|
|
}
|
|
// InternalRDL.g:3325:2: ( rule__PropertyDefinition__TypeAssignment_3_2_1_1_3 )
|
|
// InternalRDL.g:3325:3: rule__PropertyDefinition__TypeAssignment_3_2_1_1_3
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__TypeAssignment_3_2_1_1_3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypeAssignment_3_2_1_1_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_1__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_1__4"
|
|
// InternalRDL.g:3333:1: rule__PropertyDefinition__Group_3_2_1_1__4 : rule__PropertyDefinition__Group_3_2_1_1__4__Impl ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_1__4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3337:1: ( rule__PropertyDefinition__Group_3_2_1_1__4__Impl )
|
|
// InternalRDL.g:3338:2: rule__PropertyDefinition__Group_3_2_1_1__4__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefinition__Group_3_2_1_1__4__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_1__4"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__Group_3_2_1_1__4__Impl"
|
|
// InternalRDL.g:3344:1: rule__PropertyDefinition__Group_3_2_1_1__4__Impl : ( ';' ) ;
|
|
public final void rule__PropertyDefinition__Group_3_2_1_1__4__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3348:1: ( ( ';' ) )
|
|
// InternalRDL.g:3349:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:3349:1: ( ';' )
|
|
// InternalRDL.g:3350:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_3_2_1_1_4());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getSemicolonKeyword_3_2_1_1_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__Group_3_2_1_1__4__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__Group__0"
|
|
// InternalRDL.g:3360:1: rule__PropertyDefault__Group__0 : rule__PropertyDefault__Group__0__Impl rule__PropertyDefault__Group__1 ;
|
|
public final void rule__PropertyDefault__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3364:1: ( rule__PropertyDefault__Group__0__Impl rule__PropertyDefault__Group__1 )
|
|
// InternalRDL.g:3365:2: rule__PropertyDefault__Group__0__Impl rule__PropertyDefault__Group__1
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__PropertyDefault__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefault__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__Group__0__Impl"
|
|
// InternalRDL.g:3372:1: rule__PropertyDefault__Group__0__Impl : ( 'default' ) ;
|
|
public final void rule__PropertyDefault__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3376:1: ( ( 'default' ) )
|
|
// InternalRDL.g:3377:1: ( 'default' )
|
|
{
|
|
// InternalRDL.g:3377:1: ( 'default' )
|
|
// InternalRDL.g:3378:2: 'default'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getDefaultKeyword_0());
|
|
}
|
|
match(input,120,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getDefaultKeyword_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__Group__1"
|
|
// InternalRDL.g:3387:1: rule__PropertyDefault__Group__1 : rule__PropertyDefault__Group__1__Impl rule__PropertyDefault__Group__2 ;
|
|
public final void rule__PropertyDefault__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3391:1: ( rule__PropertyDefault__Group__1__Impl rule__PropertyDefault__Group__2 )
|
|
// InternalRDL.g:3392:2: rule__PropertyDefault__Group__1__Impl rule__PropertyDefault__Group__2
|
|
{
|
|
pushFollow(FOLLOW_15);
|
|
rule__PropertyDefault__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefault__Group__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__Group__1__Impl"
|
|
// InternalRDL.g:3399:1: rule__PropertyDefault__Group__1__Impl : ( '=' ) ;
|
|
public final void rule__PropertyDefault__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3403:1: ( ( '=' ) )
|
|
// InternalRDL.g:3404:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:3404:1: ( '=' )
|
|
// InternalRDL.g:3405:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getEqualsSignKeyword_1());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getEqualsSignKeyword_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__Group__2"
|
|
// InternalRDL.g:3414:1: rule__PropertyDefault__Group__2 : rule__PropertyDefault__Group__2__Impl rule__PropertyDefault__Group__3 ;
|
|
public final void rule__PropertyDefault__Group__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3418:1: ( rule__PropertyDefault__Group__2__Impl rule__PropertyDefault__Group__3 )
|
|
// InternalRDL.g:3419:2: rule__PropertyDefault__Group__2__Impl rule__PropertyDefault__Group__3
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__PropertyDefault__Group__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefault__Group__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__Group__2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__Group__2__Impl"
|
|
// InternalRDL.g:3426:1: rule__PropertyDefault__Group__2__Impl : ( ( rule__PropertyDefault__Alternatives_2 ) ) ;
|
|
public final void rule__PropertyDefault__Group__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3430:1: ( ( ( rule__PropertyDefault__Alternatives_2 ) ) )
|
|
// InternalRDL.g:3431:1: ( ( rule__PropertyDefault__Alternatives_2 ) )
|
|
{
|
|
// InternalRDL.g:3431:1: ( ( rule__PropertyDefault__Alternatives_2 ) )
|
|
// InternalRDL.g:3432:2: ( rule__PropertyDefault__Alternatives_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getAlternatives_2());
|
|
}
|
|
// InternalRDL.g:3433:2: ( rule__PropertyDefault__Alternatives_2 )
|
|
// InternalRDL.g:3433:3: rule__PropertyDefault__Alternatives_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefault__Alternatives_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getAlternatives_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__Group__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__Group__3"
|
|
// InternalRDL.g:3441:1: rule__PropertyDefault__Group__3 : rule__PropertyDefault__Group__3__Impl ;
|
|
public final void rule__PropertyDefault__Group__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3445:1: ( rule__PropertyDefault__Group__3__Impl )
|
|
// InternalRDL.g:3446:2: rule__PropertyDefault__Group__3__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyDefault__Group__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__Group__3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__Group__3__Impl"
|
|
// InternalRDL.g:3452:1: rule__PropertyDefault__Group__3__Impl : ( ';' ) ;
|
|
public final void rule__PropertyDefault__Group__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3456:1: ( ( ';' ) )
|
|
// InternalRDL.g:3457:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:3457:1: ( ';' )
|
|
// InternalRDL.g:3458:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getSemicolonKeyword_3());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getSemicolonKeyword_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__Group__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group__0"
|
|
// InternalRDL.g:3468:1: rule__PropertyUsage__Group__0 : rule__PropertyUsage__Group__0__Impl rule__PropertyUsage__Group__1 ;
|
|
public final void rule__PropertyUsage__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3472:1: ( rule__PropertyUsage__Group__0__Impl rule__PropertyUsage__Group__1 )
|
|
// InternalRDL.g:3473:2: rule__PropertyUsage__Group__0__Impl rule__PropertyUsage__Group__1
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__PropertyUsage__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyUsage__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group__0__Impl"
|
|
// InternalRDL.g:3480:1: rule__PropertyUsage__Group__0__Impl : ( 'component' ) ;
|
|
public final void rule__PropertyUsage__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3484:1: ( ( 'component' ) )
|
|
// InternalRDL.g:3485:1: ( 'component' )
|
|
{
|
|
// InternalRDL.g:3485:1: ( 'component' )
|
|
// InternalRDL.g:3486:2: 'component'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyUsageAccess().getComponentKeyword_0());
|
|
}
|
|
match(input,121,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyUsageAccess().getComponentKeyword_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group__1"
|
|
// InternalRDL.g:3495:1: rule__PropertyUsage__Group__1 : rule__PropertyUsage__Group__1__Impl rule__PropertyUsage__Group__2 ;
|
|
public final void rule__PropertyUsage__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3499:1: ( rule__PropertyUsage__Group__1__Impl rule__PropertyUsage__Group__2 )
|
|
// InternalRDL.g:3500:2: rule__PropertyUsage__Group__1__Impl rule__PropertyUsage__Group__2
|
|
{
|
|
pushFollow(FOLLOW_16);
|
|
rule__PropertyUsage__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyUsage__Group__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group__1__Impl"
|
|
// InternalRDL.g:3507:1: rule__PropertyUsage__Group__1__Impl : ( '=' ) ;
|
|
public final void rule__PropertyUsage__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3511:1: ( ( '=' ) )
|
|
// InternalRDL.g:3512:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:3512:1: ( '=' )
|
|
// InternalRDL.g:3513:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyUsageAccess().getEqualsSignKeyword_1());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyUsageAccess().getEqualsSignKeyword_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group__2"
|
|
// InternalRDL.g:3522:1: rule__PropertyUsage__Group__2 : rule__PropertyUsage__Group__2__Impl rule__PropertyUsage__Group__3 ;
|
|
public final void rule__PropertyUsage__Group__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3526:1: ( rule__PropertyUsage__Group__2__Impl rule__PropertyUsage__Group__3 )
|
|
// InternalRDL.g:3527:2: rule__PropertyUsage__Group__2__Impl rule__PropertyUsage__Group__3
|
|
{
|
|
pushFollow(FOLLOW_17);
|
|
rule__PropertyUsage__Group__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyUsage__Group__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group__2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group__2__Impl"
|
|
// InternalRDL.g:3534:1: rule__PropertyUsage__Group__2__Impl : ( ( rule__PropertyUsage__ComponentsAssignment_2 ) ) ;
|
|
public final void rule__PropertyUsage__Group__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3538:1: ( ( ( rule__PropertyUsage__ComponentsAssignment_2 ) ) )
|
|
// InternalRDL.g:3539:1: ( ( rule__PropertyUsage__ComponentsAssignment_2 ) )
|
|
{
|
|
// InternalRDL.g:3539:1: ( ( rule__PropertyUsage__ComponentsAssignment_2 ) )
|
|
// InternalRDL.g:3540:2: ( rule__PropertyUsage__ComponentsAssignment_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyUsageAccess().getComponentsAssignment_2());
|
|
}
|
|
// InternalRDL.g:3541:2: ( rule__PropertyUsage__ComponentsAssignment_2 )
|
|
// InternalRDL.g:3541:3: rule__PropertyUsage__ComponentsAssignment_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyUsage__ComponentsAssignment_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyUsageAccess().getComponentsAssignment_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group__3"
|
|
// InternalRDL.g:3549:1: rule__PropertyUsage__Group__3 : rule__PropertyUsage__Group__3__Impl rule__PropertyUsage__Group__4 ;
|
|
public final void rule__PropertyUsage__Group__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3553:1: ( rule__PropertyUsage__Group__3__Impl rule__PropertyUsage__Group__4 )
|
|
// InternalRDL.g:3554:2: rule__PropertyUsage__Group__3__Impl rule__PropertyUsage__Group__4
|
|
{
|
|
pushFollow(FOLLOW_17);
|
|
rule__PropertyUsage__Group__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyUsage__Group__4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group__3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group__3__Impl"
|
|
// InternalRDL.g:3561:1: rule__PropertyUsage__Group__3__Impl : ( ( rule__PropertyUsage__Group_3__0 )* ) ;
|
|
public final void rule__PropertyUsage__Group__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3565:1: ( ( ( rule__PropertyUsage__Group_3__0 )* ) )
|
|
// InternalRDL.g:3566:1: ( ( rule__PropertyUsage__Group_3__0 )* )
|
|
{
|
|
// InternalRDL.g:3566:1: ( ( rule__PropertyUsage__Group_3__0 )* )
|
|
// InternalRDL.g:3567:2: ( rule__PropertyUsage__Group_3__0 )*
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyUsageAccess().getGroup_3());
|
|
}
|
|
// InternalRDL.g:3568:2: ( rule__PropertyUsage__Group_3__0 )*
|
|
loop29:
|
|
do {
|
|
int alt29=2;
|
|
int LA29_0 = input.LA(1);
|
|
|
|
if ( (LA29_0==122) ) {
|
|
alt29=1;
|
|
}
|
|
|
|
|
|
switch (alt29) {
|
|
case 1 :
|
|
// InternalRDL.g:3568:3: rule__PropertyUsage__Group_3__0
|
|
{
|
|
pushFollow(FOLLOW_18);
|
|
rule__PropertyUsage__Group_3__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop29;
|
|
}
|
|
} while (true);
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyUsageAccess().getGroup_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group__4"
|
|
// InternalRDL.g:3576:1: rule__PropertyUsage__Group__4 : rule__PropertyUsage__Group__4__Impl ;
|
|
public final void rule__PropertyUsage__Group__4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3580:1: ( rule__PropertyUsage__Group__4__Impl )
|
|
// InternalRDL.g:3581:2: rule__PropertyUsage__Group__4__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyUsage__Group__4__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group__4"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group__4__Impl"
|
|
// InternalRDL.g:3587:1: rule__PropertyUsage__Group__4__Impl : ( ';' ) ;
|
|
public final void rule__PropertyUsage__Group__4__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3591:1: ( ( ';' ) )
|
|
// InternalRDL.g:3592:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:3592:1: ( ';' )
|
|
// InternalRDL.g:3593:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyUsageAccess().getSemicolonKeyword_4());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyUsageAccess().getSemicolonKeyword_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group__4__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group_3__0"
|
|
// InternalRDL.g:3603:1: rule__PropertyUsage__Group_3__0 : rule__PropertyUsage__Group_3__0__Impl rule__PropertyUsage__Group_3__1 ;
|
|
public final void rule__PropertyUsage__Group_3__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3607:1: ( rule__PropertyUsage__Group_3__0__Impl rule__PropertyUsage__Group_3__1 )
|
|
// InternalRDL.g:3608:2: rule__PropertyUsage__Group_3__0__Impl rule__PropertyUsage__Group_3__1
|
|
{
|
|
pushFollow(FOLLOW_16);
|
|
rule__PropertyUsage__Group_3__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyUsage__Group_3__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group_3__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group_3__0__Impl"
|
|
// InternalRDL.g:3615:1: rule__PropertyUsage__Group_3__0__Impl : ( '|' ) ;
|
|
public final void rule__PropertyUsage__Group_3__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3619:1: ( ( '|' ) )
|
|
// InternalRDL.g:3620:1: ( '|' )
|
|
{
|
|
// InternalRDL.g:3620:1: ( '|' )
|
|
// InternalRDL.g:3621:2: '|'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyUsageAccess().getVerticalLineKeyword_3_0());
|
|
}
|
|
match(input,122,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyUsageAccess().getVerticalLineKeyword_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group_3__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group_3__1"
|
|
// InternalRDL.g:3630:1: rule__PropertyUsage__Group_3__1 : rule__PropertyUsage__Group_3__1__Impl ;
|
|
public final void rule__PropertyUsage__Group_3__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3634:1: ( rule__PropertyUsage__Group_3__1__Impl )
|
|
// InternalRDL.g:3635:2: rule__PropertyUsage__Group_3__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyUsage__Group_3__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group_3__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__Group_3__1__Impl"
|
|
// InternalRDL.g:3641:1: rule__PropertyUsage__Group_3__1__Impl : ( ( rule__PropertyUsage__ComponentsAssignment_3_1 ) ) ;
|
|
public final void rule__PropertyUsage__Group_3__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3645:1: ( ( ( rule__PropertyUsage__ComponentsAssignment_3_1 ) ) )
|
|
// InternalRDL.g:3646:1: ( ( rule__PropertyUsage__ComponentsAssignment_3_1 ) )
|
|
{
|
|
// InternalRDL.g:3646:1: ( ( rule__PropertyUsage__ComponentsAssignment_3_1 ) )
|
|
// InternalRDL.g:3647:2: ( rule__PropertyUsage__ComponentsAssignment_3_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyUsageAccess().getComponentsAssignment_3_1());
|
|
}
|
|
// InternalRDL.g:3648:2: ( rule__PropertyUsage__ComponentsAssignment_3_1 )
|
|
// InternalRDL.g:3648:3: rule__PropertyUsage__ComponentsAssignment_3_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyUsage__ComponentsAssignment_3_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyUsageAccess().getComponentsAssignment_3_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__Group_3__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group__0"
|
|
// InternalRDL.g:3657:1: rule__ComponentDefinition__Group__0 : rule__ComponentDefinition__Group__0__Impl rule__ComponentDefinition__Group__1 ;
|
|
public final void rule__ComponentDefinition__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3661:1: ( rule__ComponentDefinition__Group__0__Impl rule__ComponentDefinition__Group__1 )
|
|
// InternalRDL.g:3662:2: rule__ComponentDefinition__Group__0__Impl rule__ComponentDefinition__Group__1
|
|
{
|
|
pushFollow(FOLLOW_19);
|
|
rule__ComponentDefinition__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group__0__Impl"
|
|
// InternalRDL.g:3669:1: rule__ComponentDefinition__Group__0__Impl : ( ( rule__ComponentDefinition__TypeAssignment_0 ) ) ;
|
|
public final void rule__ComponentDefinition__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3673:1: ( ( ( rule__ComponentDefinition__TypeAssignment_0 ) ) )
|
|
// InternalRDL.g:3674:1: ( ( rule__ComponentDefinition__TypeAssignment_0 ) )
|
|
{
|
|
// InternalRDL.g:3674:1: ( ( rule__ComponentDefinition__TypeAssignment_0 ) )
|
|
// InternalRDL.g:3675:2: ( rule__ComponentDefinition__TypeAssignment_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getTypeAssignment_0());
|
|
}
|
|
// InternalRDL.g:3676:2: ( rule__ComponentDefinition__TypeAssignment_0 )
|
|
// InternalRDL.g:3676:3: rule__ComponentDefinition__TypeAssignment_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__TypeAssignment_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getTypeAssignment_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group__1"
|
|
// InternalRDL.g:3684:1: rule__ComponentDefinition__Group__1 : rule__ComponentDefinition__Group__1__Impl rule__ComponentDefinition__Group__2 ;
|
|
public final void rule__ComponentDefinition__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3688:1: ( rule__ComponentDefinition__Group__1__Impl rule__ComponentDefinition__Group__2 )
|
|
// InternalRDL.g:3689:2: rule__ComponentDefinition__Group__1__Impl rule__ComponentDefinition__Group__2
|
|
{
|
|
pushFollow(FOLLOW_19);
|
|
rule__ComponentDefinition__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group__1__Impl"
|
|
// InternalRDL.g:3696:1: rule__ComponentDefinition__Group__1__Impl : ( ( rule__ComponentDefinition__NameAssignment_1 )? ) ;
|
|
public final void rule__ComponentDefinition__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3700:1: ( ( ( rule__ComponentDefinition__NameAssignment_1 )? ) )
|
|
// InternalRDL.g:3701:1: ( ( rule__ComponentDefinition__NameAssignment_1 )? )
|
|
{
|
|
// InternalRDL.g:3701:1: ( ( rule__ComponentDefinition__NameAssignment_1 )? )
|
|
// InternalRDL.g:3702:2: ( rule__ComponentDefinition__NameAssignment_1 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getNameAssignment_1());
|
|
}
|
|
// InternalRDL.g:3703:2: ( rule__ComponentDefinition__NameAssignment_1 )?
|
|
int alt30=2;
|
|
int LA30_0 = input.LA(1);
|
|
|
|
if ( (LA30_0==RULE_ID) ) {
|
|
alt30=1;
|
|
}
|
|
switch (alt30) {
|
|
case 1 :
|
|
// InternalRDL.g:3703:3: rule__ComponentDefinition__NameAssignment_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__NameAssignment_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getNameAssignment_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group__2"
|
|
// InternalRDL.g:3711:1: rule__ComponentDefinition__Group__2 : rule__ComponentDefinition__Group__2__Impl rule__ComponentDefinition__Group__3 ;
|
|
public final void rule__ComponentDefinition__Group__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3715:1: ( rule__ComponentDefinition__Group__2__Impl rule__ComponentDefinition__Group__3 )
|
|
// InternalRDL.g:3716:2: rule__ComponentDefinition__Group__2__Impl rule__ComponentDefinition__Group__3
|
|
{
|
|
pushFollow(FOLLOW_20);
|
|
rule__ComponentDefinition__Group__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group__2"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group__2__Impl"
|
|
// InternalRDL.g:3723:1: rule__ComponentDefinition__Group__2__Impl : ( '{' ) ;
|
|
public final void rule__ComponentDefinition__Group__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3727:1: ( ( '{' ) )
|
|
// InternalRDL.g:3728:1: ( '{' )
|
|
{
|
|
// InternalRDL.g:3728:1: ( '{' )
|
|
// InternalRDL.g:3729:2: '{'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getLeftCurlyBracketKeyword_2());
|
|
}
|
|
match(input,116,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getLeftCurlyBracketKeyword_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group__3"
|
|
// InternalRDL.g:3738:1: rule__ComponentDefinition__Group__3 : rule__ComponentDefinition__Group__3__Impl rule__ComponentDefinition__Group__4 ;
|
|
public final void rule__ComponentDefinition__Group__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3742:1: ( rule__ComponentDefinition__Group__3__Impl rule__ComponentDefinition__Group__4 )
|
|
// InternalRDL.g:3743:2: rule__ComponentDefinition__Group__3__Impl rule__ComponentDefinition__Group__4
|
|
{
|
|
pushFollow(FOLLOW_20);
|
|
rule__ComponentDefinition__Group__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group__4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group__3"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group__3__Impl"
|
|
// InternalRDL.g:3750:1: rule__ComponentDefinition__Group__3__Impl : ( ( rule__ComponentDefinition__Alternatives_3 )* ) ;
|
|
public final void rule__ComponentDefinition__Group__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3754:1: ( ( ( rule__ComponentDefinition__Alternatives_3 )* ) )
|
|
// InternalRDL.g:3755:1: ( ( rule__ComponentDefinition__Alternatives_3 )* )
|
|
{
|
|
// InternalRDL.g:3755:1: ( ( rule__ComponentDefinition__Alternatives_3 )* )
|
|
// InternalRDL.g:3756:2: ( rule__ComponentDefinition__Alternatives_3 )*
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getAlternatives_3());
|
|
}
|
|
// InternalRDL.g:3757:2: ( rule__ComponentDefinition__Alternatives_3 )*
|
|
loop31:
|
|
do {
|
|
int alt31=2;
|
|
int LA31_0 = input.LA(1);
|
|
|
|
if ( (LA31_0==RULE_ID||(LA31_0>=15 && LA31_0<=18)||LA31_0==20||(LA31_0>=22 && LA31_0<=97)||(LA31_0>=108 && LA31_0<=112)||LA31_0==120||LA31_0==123||(LA31_0>=133 && LA31_0<=134)) ) {
|
|
alt31=1;
|
|
}
|
|
|
|
|
|
switch (alt31) {
|
|
case 1 :
|
|
// InternalRDL.g:3757:3: rule__ComponentDefinition__Alternatives_3
|
|
{
|
|
pushFollow(FOLLOW_21);
|
|
rule__ComponentDefinition__Alternatives_3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop31;
|
|
}
|
|
} while (true);
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getAlternatives_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group__4"
|
|
// InternalRDL.g:3765:1: rule__ComponentDefinition__Group__4 : rule__ComponentDefinition__Group__4__Impl ;
|
|
public final void rule__ComponentDefinition__Group__4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3769:1: ( rule__ComponentDefinition__Group__4__Impl )
|
|
// InternalRDL.g:3770:2: rule__ComponentDefinition__Group__4__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group__4__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group__4"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group__4__Impl"
|
|
// InternalRDL.g:3776:1: rule__ComponentDefinition__Group__4__Impl : ( '}' ) ;
|
|
public final void rule__ComponentDefinition__Group__4__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3780:1: ( ( '}' ) )
|
|
// InternalRDL.g:3781:1: ( '}' )
|
|
{
|
|
// InternalRDL.g:3781:1: ( '}' )
|
|
// InternalRDL.g:3782:2: '}'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getRightCurlyBracketKeyword_4());
|
|
}
|
|
match(input,117,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getRightCurlyBracketKeyword_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group__4__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_0__0"
|
|
// InternalRDL.g:3792:1: rule__ComponentDefinition__Group_3_0__0 : rule__ComponentDefinition__Group_3_0__0__Impl rule__ComponentDefinition__Group_3_0__1 ;
|
|
public final void rule__ComponentDefinition__Group_3_0__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3796:1: ( rule__ComponentDefinition__Group_3_0__0__Impl rule__ComponentDefinition__Group_3_0__1 )
|
|
// InternalRDL.g:3797:2: rule__ComponentDefinition__Group_3_0__0__Impl rule__ComponentDefinition__Group_3_0__1
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__ComponentDefinition__Group_3_0__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_0__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_0__0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_0__0__Impl"
|
|
// InternalRDL.g:3804:1: rule__ComponentDefinition__Group_3_0__0__Impl : ( ( rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0 ) ) ;
|
|
public final void rule__ComponentDefinition__Group_3_0__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3808:1: ( ( ( rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0 ) ) )
|
|
// InternalRDL.g:3809:1: ( ( rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0 ) )
|
|
{
|
|
// InternalRDL.g:3809:1: ( ( rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0 ) )
|
|
// InternalRDL.g:3810:2: ( rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getComponentDefinitionsAssignment_3_0_0());
|
|
}
|
|
// InternalRDL.g:3811:2: ( rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0 )
|
|
// InternalRDL.g:3811:3: rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getComponentDefinitionsAssignment_3_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_0__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_0__1"
|
|
// InternalRDL.g:3819:1: rule__ComponentDefinition__Group_3_0__1 : rule__ComponentDefinition__Group_3_0__1__Impl ;
|
|
public final void rule__ComponentDefinition__Group_3_0__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3823:1: ( rule__ComponentDefinition__Group_3_0__1__Impl )
|
|
// InternalRDL.g:3824:2: rule__ComponentDefinition__Group_3_0__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_0__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_0__1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_0__1__Impl"
|
|
// InternalRDL.g:3830:1: rule__ComponentDefinition__Group_3_0__1__Impl : ( ';' ) ;
|
|
public final void rule__ComponentDefinition__Group_3_0__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3834:1: ( ( ';' ) )
|
|
// InternalRDL.g:3835:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:3835:1: ( ';' )
|
|
// InternalRDL.g:3836:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_0_1());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_0__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_1__0"
|
|
// InternalRDL.g:3846:1: rule__ComponentDefinition__Group_3_1__0 : rule__ComponentDefinition__Group_3_1__0__Impl rule__ComponentDefinition__Group_3_1__1 ;
|
|
public final void rule__ComponentDefinition__Group_3_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3850:1: ( rule__ComponentDefinition__Group_3_1__0__Impl rule__ComponentDefinition__Group_3_1__1 )
|
|
// InternalRDL.g:3851:2: rule__ComponentDefinition__Group_3_1__0__Impl rule__ComponentDefinition__Group_3_1__1
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__ComponentDefinition__Group_3_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_1__0__Impl"
|
|
// InternalRDL.g:3858:1: rule__ComponentDefinition__Group_3_1__0__Impl : ( ( rule__ComponentDefinition__InstantiationsAssignment_3_1_0 ) ) ;
|
|
public final void rule__ComponentDefinition__Group_3_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3862:1: ( ( ( rule__ComponentDefinition__InstantiationsAssignment_3_1_0 ) ) )
|
|
// InternalRDL.g:3863:1: ( ( rule__ComponentDefinition__InstantiationsAssignment_3_1_0 ) )
|
|
{
|
|
// InternalRDL.g:3863:1: ( ( rule__ComponentDefinition__InstantiationsAssignment_3_1_0 ) )
|
|
// InternalRDL.g:3864:2: ( rule__ComponentDefinition__InstantiationsAssignment_3_1_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getInstantiationsAssignment_3_1_0());
|
|
}
|
|
// InternalRDL.g:3865:2: ( rule__ComponentDefinition__InstantiationsAssignment_3_1_0 )
|
|
// InternalRDL.g:3865:3: rule__ComponentDefinition__InstantiationsAssignment_3_1_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__InstantiationsAssignment_3_1_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getInstantiationsAssignment_3_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_1__1"
|
|
// InternalRDL.g:3873:1: rule__ComponentDefinition__Group_3_1__1 : rule__ComponentDefinition__Group_3_1__1__Impl ;
|
|
public final void rule__ComponentDefinition__Group_3_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3877:1: ( rule__ComponentDefinition__Group_3_1__1__Impl )
|
|
// InternalRDL.g:3878:2: rule__ComponentDefinition__Group_3_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_1__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_1__1__Impl"
|
|
// InternalRDL.g:3884:1: rule__ComponentDefinition__Group_3_1__1__Impl : ( ';' ) ;
|
|
public final void rule__ComponentDefinition__Group_3_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3888:1: ( ( ';' ) )
|
|
// InternalRDL.g:3889:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:3889:1: ( ';' )
|
|
// InternalRDL.g:3890:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_1_1());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_2__0"
|
|
// InternalRDL.g:3900:1: rule__ComponentDefinition__Group_3_2__0 : rule__ComponentDefinition__Group_3_2__0__Impl rule__ComponentDefinition__Group_3_2__1 ;
|
|
public final void rule__ComponentDefinition__Group_3_2__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3904:1: ( rule__ComponentDefinition__Group_3_2__0__Impl rule__ComponentDefinition__Group_3_2__1 )
|
|
// InternalRDL.g:3905:2: rule__ComponentDefinition__Group_3_2__0__Impl rule__ComponentDefinition__Group_3_2__1
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__ComponentDefinition__Group_3_2__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_2__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_2__0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_2__0__Impl"
|
|
// InternalRDL.g:3912:1: rule__ComponentDefinition__Group_3_2__0__Impl : ( ( rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0 ) ) ;
|
|
public final void rule__ComponentDefinition__Group_3_2__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3916:1: ( ( ( rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0 ) ) )
|
|
// InternalRDL.g:3917:1: ( ( rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0 ) )
|
|
{
|
|
// InternalRDL.g:3917:1: ( ( rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0 ) )
|
|
// InternalRDL.g:3918:2: ( rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getPropertyAssignmentsAssignment_3_2_0());
|
|
}
|
|
// InternalRDL.g:3919:2: ( rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0 )
|
|
// InternalRDL.g:3919:3: rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getPropertyAssignmentsAssignment_3_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_2__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_2__1"
|
|
// InternalRDL.g:3927:1: rule__ComponentDefinition__Group_3_2__1 : rule__ComponentDefinition__Group_3_2__1__Impl ;
|
|
public final void rule__ComponentDefinition__Group_3_2__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3931:1: ( rule__ComponentDefinition__Group_3_2__1__Impl )
|
|
// InternalRDL.g:3932:2: rule__ComponentDefinition__Group_3_2__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_2__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_2__1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_2__1__Impl"
|
|
// InternalRDL.g:3938:1: rule__ComponentDefinition__Group_3_2__1__Impl : ( ';' ) ;
|
|
public final void rule__ComponentDefinition__Group_3_2__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3942:1: ( ( ';' ) )
|
|
// InternalRDL.g:3943:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:3943:1: ( ';' )
|
|
// InternalRDL.g:3944:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_2_1());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_2_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_2__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_3__0"
|
|
// InternalRDL.g:3954:1: rule__ComponentDefinition__Group_3_3__0 : rule__ComponentDefinition__Group_3_3__0__Impl rule__ComponentDefinition__Group_3_3__1 ;
|
|
public final void rule__ComponentDefinition__Group_3_3__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3958:1: ( rule__ComponentDefinition__Group_3_3__0__Impl rule__ComponentDefinition__Group_3_3__1 )
|
|
// InternalRDL.g:3959:2: rule__ComponentDefinition__Group_3_3__0__Impl rule__ComponentDefinition__Group_3_3__1
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__ComponentDefinition__Group_3_3__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_3__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_3__0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_3__0__Impl"
|
|
// InternalRDL.g:3966:1: rule__ComponentDefinition__Group_3_3__0__Impl : ( ( rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0 ) ) ;
|
|
public final void rule__ComponentDefinition__Group_3_3__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3970:1: ( ( ( rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0 ) ) )
|
|
// InternalRDL.g:3971:1: ( ( rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0 ) )
|
|
{
|
|
// InternalRDL.g:3971:1: ( ( rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0 ) )
|
|
// InternalRDL.g:3972:2: ( rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getEnumDefinitionsAssignment_3_3_0());
|
|
}
|
|
// InternalRDL.g:3973:2: ( rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0 )
|
|
// InternalRDL.g:3973:3: rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getEnumDefinitionsAssignment_3_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_3__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_3__1"
|
|
// InternalRDL.g:3981:1: rule__ComponentDefinition__Group_3_3__1 : rule__ComponentDefinition__Group_3_3__1__Impl ;
|
|
public final void rule__ComponentDefinition__Group_3_3__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3985:1: ( rule__ComponentDefinition__Group_3_3__1__Impl )
|
|
// InternalRDL.g:3986:2: rule__ComponentDefinition__Group_3_3__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_3__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_3__1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__Group_3_3__1__Impl"
|
|
// InternalRDL.g:3992:1: rule__ComponentDefinition__Group_3_3__1__Impl : ( ';' ) ;
|
|
public final void rule__ComponentDefinition__Group_3_3__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:3996:1: ( ( ';' ) )
|
|
// InternalRDL.g:3997:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:3997:1: ( ';' )
|
|
// InternalRDL.g:3998:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_3_1());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getSemicolonKeyword_3_3_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__Group_3_3__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group__0"
|
|
// InternalRDL.g:4008:1: rule__Instantiation__Group__0 : rule__Instantiation__Group__0__Impl rule__Instantiation__Group__1 ;
|
|
public final void rule__Instantiation__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4012:1: ( rule__Instantiation__Group__0__Impl rule__Instantiation__Group__1 )
|
|
// InternalRDL.g:4013:2: rule__Instantiation__Group__0__Impl rule__Instantiation__Group__1
|
|
{
|
|
pushFollow(FOLLOW_6);
|
|
rule__Instantiation__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group__0__Impl"
|
|
// InternalRDL.g:4020:1: rule__Instantiation__Group__0__Impl : ( ( rule__Instantiation__Alternatives_0 ) ) ;
|
|
public final void rule__Instantiation__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4024:1: ( ( ( rule__Instantiation__Alternatives_0 ) ) )
|
|
// InternalRDL.g:4025:1: ( ( rule__Instantiation__Alternatives_0 ) )
|
|
{
|
|
// InternalRDL.g:4025:1: ( ( rule__Instantiation__Alternatives_0 ) )
|
|
// InternalRDL.g:4026:2: ( rule__Instantiation__Alternatives_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getAlternatives_0());
|
|
}
|
|
// InternalRDL.g:4027:2: ( rule__Instantiation__Alternatives_0 )
|
|
// InternalRDL.g:4027:3: rule__Instantiation__Alternatives_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Alternatives_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getAlternatives_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group__1"
|
|
// InternalRDL.g:4035:1: rule__Instantiation__Group__1 : rule__Instantiation__Group__1__Impl rule__Instantiation__Group__2 ;
|
|
public final void rule__Instantiation__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4039:1: ( rule__Instantiation__Group__1__Impl rule__Instantiation__Group__2 )
|
|
// InternalRDL.g:4040:2: rule__Instantiation__Group__1__Impl rule__Instantiation__Group__2
|
|
{
|
|
pushFollow(FOLLOW_22);
|
|
rule__Instantiation__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group__1__Impl"
|
|
// InternalRDL.g:4047:1: rule__Instantiation__Group__1__Impl : ( ( rule__Instantiation__ComponentInstancesAssignment_1 ) ) ;
|
|
public final void rule__Instantiation__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4051:1: ( ( ( rule__Instantiation__ComponentInstancesAssignment_1 ) ) )
|
|
// InternalRDL.g:4052:1: ( ( rule__Instantiation__ComponentInstancesAssignment_1 ) )
|
|
{
|
|
// InternalRDL.g:4052:1: ( ( rule__Instantiation__ComponentInstancesAssignment_1 ) )
|
|
// InternalRDL.g:4053:2: ( rule__Instantiation__ComponentInstancesAssignment_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getComponentInstancesAssignment_1());
|
|
}
|
|
// InternalRDL.g:4054:2: ( rule__Instantiation__ComponentInstancesAssignment_1 )
|
|
// InternalRDL.g:4054:3: rule__Instantiation__ComponentInstancesAssignment_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__ComponentInstancesAssignment_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getComponentInstancesAssignment_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group__2"
|
|
// InternalRDL.g:4062:1: rule__Instantiation__Group__2 : rule__Instantiation__Group__2__Impl ;
|
|
public final void rule__Instantiation__Group__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4066:1: ( rule__Instantiation__Group__2__Impl )
|
|
// InternalRDL.g:4067:2: rule__Instantiation__Group__2__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group__2"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group__2__Impl"
|
|
// InternalRDL.g:4073:1: rule__Instantiation__Group__2__Impl : ( ( rule__Instantiation__Group_2__0 )* ) ;
|
|
public final void rule__Instantiation__Group__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4077:1: ( ( ( rule__Instantiation__Group_2__0 )* ) )
|
|
// InternalRDL.g:4078:1: ( ( rule__Instantiation__Group_2__0 )* )
|
|
{
|
|
// InternalRDL.g:4078:1: ( ( rule__Instantiation__Group_2__0 )* )
|
|
// InternalRDL.g:4079:2: ( rule__Instantiation__Group_2__0 )*
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getGroup_2());
|
|
}
|
|
// InternalRDL.g:4080:2: ( rule__Instantiation__Group_2__0 )*
|
|
loop32:
|
|
do {
|
|
int alt32=2;
|
|
int LA32_0 = input.LA(1);
|
|
|
|
if ( (LA32_0==124) ) {
|
|
alt32=1;
|
|
}
|
|
|
|
|
|
switch (alt32) {
|
|
case 1 :
|
|
// InternalRDL.g:4080:3: rule__Instantiation__Group_2__0
|
|
{
|
|
pushFollow(FOLLOW_23);
|
|
rule__Instantiation__Group_2__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop32;
|
|
}
|
|
} while (true);
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getGroup_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_0__0"
|
|
// InternalRDL.g:4089:1: rule__Instantiation__Group_0_0__0 : rule__Instantiation__Group_0_0__0__Impl rule__Instantiation__Group_0_0__1 ;
|
|
public final void rule__Instantiation__Group_0_0__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4093:1: ( rule__Instantiation__Group_0_0__0__Impl rule__Instantiation__Group_0_0__1 )
|
|
// InternalRDL.g:4094:2: rule__Instantiation__Group_0_0__0__Impl rule__Instantiation__Group_0_0__1
|
|
{
|
|
pushFollow(FOLLOW_24);
|
|
rule__Instantiation__Group_0_0__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group_0_0__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_0_0__0"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_0__0__Impl"
|
|
// InternalRDL.g:4101:1: rule__Instantiation__Group_0_0__0__Impl : ( ( rule__Instantiation__InstanceTypeAssignment_0_0_0 )? ) ;
|
|
public final void rule__Instantiation__Group_0_0__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4105:1: ( ( ( rule__Instantiation__InstanceTypeAssignment_0_0_0 )? ) )
|
|
// InternalRDL.g:4106:1: ( ( rule__Instantiation__InstanceTypeAssignment_0_0_0 )? )
|
|
{
|
|
// InternalRDL.g:4106:1: ( ( rule__Instantiation__InstanceTypeAssignment_0_0_0 )? )
|
|
// InternalRDL.g:4107:2: ( rule__Instantiation__InstanceTypeAssignment_0_0_0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getInstanceTypeAssignment_0_0_0());
|
|
}
|
|
// InternalRDL.g:4108:2: ( rule__Instantiation__InstanceTypeAssignment_0_0_0 )?
|
|
int alt33=2;
|
|
int LA33_0 = input.LA(1);
|
|
|
|
if ( (LA33_0==76||LA33_0==134) ) {
|
|
alt33=1;
|
|
}
|
|
switch (alt33) {
|
|
case 1 :
|
|
// InternalRDL.g:4108:3: rule__Instantiation__InstanceTypeAssignment_0_0_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__InstanceTypeAssignment_0_0_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getInstanceTypeAssignment_0_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_0_0__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_0__1"
|
|
// InternalRDL.g:4116:1: rule__Instantiation__Group_0_0__1 : rule__Instantiation__Group_0_0__1__Impl rule__Instantiation__Group_0_0__2 ;
|
|
public final void rule__Instantiation__Group_0_0__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4120:1: ( rule__Instantiation__Group_0_0__1__Impl rule__Instantiation__Group_0_0__2 )
|
|
// InternalRDL.g:4121:2: rule__Instantiation__Group_0_0__1__Impl rule__Instantiation__Group_0_0__2
|
|
{
|
|
pushFollow(FOLLOW_24);
|
|
rule__Instantiation__Group_0_0__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group_0_0__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_0_0__1"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_0__1__Impl"
|
|
// InternalRDL.g:4128:1: rule__Instantiation__Group_0_0__1__Impl : ( ( rule__Instantiation__Group_0_0_1__0 )? ) ;
|
|
public final void rule__Instantiation__Group_0_0__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4132:1: ( ( ( rule__Instantiation__Group_0_0_1__0 )? ) )
|
|
// InternalRDL.g:4133:1: ( ( rule__Instantiation__Group_0_0_1__0 )? )
|
|
{
|
|
// InternalRDL.g:4133:1: ( ( rule__Instantiation__Group_0_0_1__0 )? )
|
|
// InternalRDL.g:4134:2: ( rule__Instantiation__Group_0_0_1__0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getGroup_0_0_1());
|
|
}
|
|
// InternalRDL.g:4135:2: ( rule__Instantiation__Group_0_0_1__0 )?
|
|
int alt34=2;
|
|
int LA34_0 = input.LA(1);
|
|
|
|
if ( (LA34_0==123) ) {
|
|
alt34=1;
|
|
}
|
|
switch (alt34) {
|
|
case 1 :
|
|
// InternalRDL.g:4135:3: rule__Instantiation__Group_0_0_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group_0_0_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getGroup_0_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_0_0__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_0__2"
|
|
// InternalRDL.g:4143:1: rule__Instantiation__Group_0_0__2 : rule__Instantiation__Group_0_0__2__Impl ;
|
|
public final void rule__Instantiation__Group_0_0__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4147:1: ( rule__Instantiation__Group_0_0__2__Impl )
|
|
// InternalRDL.g:4148:2: rule__Instantiation__Group_0_0__2__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group_0_0__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_0_0__2"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_0__2__Impl"
|
|
// InternalRDL.g:4154:1: rule__Instantiation__Group_0_0__2__Impl : ( ( rule__Instantiation__ComponentRefAssignment_0_0_2 ) ) ;
|
|
public final void rule__Instantiation__Group_0_0__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4158:1: ( ( ( rule__Instantiation__ComponentRefAssignment_0_0_2 ) ) )
|
|
// InternalRDL.g:4159:1: ( ( rule__Instantiation__ComponentRefAssignment_0_0_2 ) )
|
|
{
|
|
// InternalRDL.g:4159:1: ( ( rule__Instantiation__ComponentRefAssignment_0_0_2 ) )
|
|
// InternalRDL.g:4160:2: ( rule__Instantiation__ComponentRefAssignment_0_0_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getComponentRefAssignment_0_0_2());
|
|
}
|
|
// InternalRDL.g:4161:2: ( rule__Instantiation__ComponentRefAssignment_0_0_2 )
|
|
// InternalRDL.g:4161:3: rule__Instantiation__ComponentRefAssignment_0_0_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__ComponentRefAssignment_0_0_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getComponentRefAssignment_0_0_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_0_0__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_0_1__0"
|
|
// InternalRDL.g:4170:1: rule__Instantiation__Group_0_0_1__0 : rule__Instantiation__Group_0_0_1__0__Impl rule__Instantiation__Group_0_0_1__1 ;
|
|
public final void rule__Instantiation__Group_0_0_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4174:1: ( rule__Instantiation__Group_0_0_1__0__Impl rule__Instantiation__Group_0_0_1__1 )
|
|
// InternalRDL.g:4175:2: rule__Instantiation__Group_0_0_1__0__Impl rule__Instantiation__Group_0_0_1__1
|
|
{
|
|
pushFollow(FOLLOW_6);
|
|
rule__Instantiation__Group_0_0_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group_0_0_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_0_0_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_0_1__0__Impl"
|
|
// InternalRDL.g:4182:1: rule__Instantiation__Group_0_0_1__0__Impl : ( 'alias' ) ;
|
|
public final void rule__Instantiation__Group_0_0_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4186:1: ( ( 'alias' ) )
|
|
// InternalRDL.g:4187:1: ( 'alias' )
|
|
{
|
|
// InternalRDL.g:4187:1: ( 'alias' )
|
|
// InternalRDL.g:4188:2: 'alias'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getAliasKeyword_0_0_1_0());
|
|
}
|
|
match(input,123,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getAliasKeyword_0_0_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_0_0_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_0_1__1"
|
|
// InternalRDL.g:4197:1: rule__Instantiation__Group_0_0_1__1 : rule__Instantiation__Group_0_0_1__1__Impl ;
|
|
public final void rule__Instantiation__Group_0_0_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4201:1: ( rule__Instantiation__Group_0_0_1__1__Impl )
|
|
// InternalRDL.g:4202:2: rule__Instantiation__Group_0_0_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group_0_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__Instantiation__Group_0_0_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_0_1__1__Impl"
|
|
// InternalRDL.g:4208:1: rule__Instantiation__Group_0_0_1__1__Impl : ( ( rule__Instantiation__AliasAssignment_0_0_1_1 ) ) ;
|
|
public final void rule__Instantiation__Group_0_0_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4212:1: ( ( ( rule__Instantiation__AliasAssignment_0_0_1_1 ) ) )
|
|
// InternalRDL.g:4213:1: ( ( rule__Instantiation__AliasAssignment_0_0_1_1 ) )
|
|
{
|
|
// InternalRDL.g:4213:1: ( ( rule__Instantiation__AliasAssignment_0_0_1_1 ) )
|
|
// InternalRDL.g:4214:2: ( rule__Instantiation__AliasAssignment_0_0_1_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getAliasAssignment_0_0_1_1());
|
|
}
|
|
// InternalRDL.g:4215:2: ( rule__Instantiation__AliasAssignment_0_0_1_1 )
|
|
// InternalRDL.g:4215:3: rule__Instantiation__AliasAssignment_0_0_1_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__AliasAssignment_0_0_1_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getAliasAssignment_0_0_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_0_0_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_1__0"
|
|
// InternalRDL.g:4224:1: rule__Instantiation__Group_0_1__0 : rule__Instantiation__Group_0_1__0__Impl rule__Instantiation__Group_0_1__1 ;
|
|
public final void rule__Instantiation__Group_0_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4228:1: ( rule__Instantiation__Group_0_1__0__Impl rule__Instantiation__Group_0_1__1 )
|
|
// InternalRDL.g:4229:2: rule__Instantiation__Group_0_1__0__Impl rule__Instantiation__Group_0_1__1
|
|
{
|
|
pushFollow(FOLLOW_25);
|
|
rule__Instantiation__Group_0_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__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__Instantiation__Group_0_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_1__0__Impl"
|
|
// InternalRDL.g:4236:1: rule__Instantiation__Group_0_1__0__Impl : ( ( rule__Instantiation__ComponentAssignment_0_1_0 ) ) ;
|
|
public final void rule__Instantiation__Group_0_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4240:1: ( ( ( rule__Instantiation__ComponentAssignment_0_1_0 ) ) )
|
|
// InternalRDL.g:4241:1: ( ( rule__Instantiation__ComponentAssignment_0_1_0 ) )
|
|
{
|
|
// InternalRDL.g:4241:1: ( ( rule__Instantiation__ComponentAssignment_0_1_0 ) )
|
|
// InternalRDL.g:4242:2: ( rule__Instantiation__ComponentAssignment_0_1_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getComponentAssignment_0_1_0());
|
|
}
|
|
// InternalRDL.g:4243:2: ( rule__Instantiation__ComponentAssignment_0_1_0 )
|
|
// InternalRDL.g:4243:3: rule__Instantiation__ComponentAssignment_0_1_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__ComponentAssignment_0_1_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getComponentAssignment_0_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_0_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_1__1"
|
|
// InternalRDL.g:4251:1: rule__Instantiation__Group_0_1__1 : rule__Instantiation__Group_0_1__1__Impl ;
|
|
public final void rule__Instantiation__Group_0_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4255:1: ( rule__Instantiation__Group_0_1__1__Impl )
|
|
// InternalRDL.g:4256:2: rule__Instantiation__Group_0_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__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__Instantiation__Group_0_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_0_1__1__Impl"
|
|
// InternalRDL.g:4262:1: rule__Instantiation__Group_0_1__1__Impl : ( ( rule__Instantiation__InstanceTypeAssignment_0_1_1 )? ) ;
|
|
public final void rule__Instantiation__Group_0_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4266:1: ( ( ( rule__Instantiation__InstanceTypeAssignment_0_1_1 )? ) )
|
|
// InternalRDL.g:4267:1: ( ( rule__Instantiation__InstanceTypeAssignment_0_1_1 )? )
|
|
{
|
|
// InternalRDL.g:4267:1: ( ( rule__Instantiation__InstanceTypeAssignment_0_1_1 )? )
|
|
// InternalRDL.g:4268:2: ( rule__Instantiation__InstanceTypeAssignment_0_1_1 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getInstanceTypeAssignment_0_1_1());
|
|
}
|
|
// InternalRDL.g:4269:2: ( rule__Instantiation__InstanceTypeAssignment_0_1_1 )?
|
|
int alt35=2;
|
|
int LA35_0 = input.LA(1);
|
|
|
|
if ( (LA35_0==76||LA35_0==134) ) {
|
|
alt35=1;
|
|
}
|
|
switch (alt35) {
|
|
case 1 :
|
|
// InternalRDL.g:4269:3: rule__Instantiation__InstanceTypeAssignment_0_1_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__InstanceTypeAssignment_0_1_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getInstanceTypeAssignment_0_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_0_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_2__0"
|
|
// InternalRDL.g:4278:1: rule__Instantiation__Group_2__0 : rule__Instantiation__Group_2__0__Impl rule__Instantiation__Group_2__1 ;
|
|
public final void rule__Instantiation__Group_2__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4282:1: ( rule__Instantiation__Group_2__0__Impl rule__Instantiation__Group_2__1 )
|
|
// InternalRDL.g:4283:2: rule__Instantiation__Group_2__0__Impl rule__Instantiation__Group_2__1
|
|
{
|
|
pushFollow(FOLLOW_6);
|
|
rule__Instantiation__Group_2__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__Group_2__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_2__0"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_2__0__Impl"
|
|
// InternalRDL.g:4290:1: rule__Instantiation__Group_2__0__Impl : ( ',' ) ;
|
|
public final void rule__Instantiation__Group_2__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4294:1: ( ( ',' ) )
|
|
// InternalRDL.g:4295:1: ( ',' )
|
|
{
|
|
// InternalRDL.g:4295:1: ( ',' )
|
|
// InternalRDL.g:4296:2: ','
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getCommaKeyword_2_0());
|
|
}
|
|
match(input,124,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getCommaKeyword_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_2__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_2__1"
|
|
// InternalRDL.g:4305:1: rule__Instantiation__Group_2__1 : rule__Instantiation__Group_2__1__Impl ;
|
|
public final void rule__Instantiation__Group_2__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4309:1: ( rule__Instantiation__Group_2__1__Impl )
|
|
// InternalRDL.g:4310:2: rule__Instantiation__Group_2__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__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__Instantiation__Group_2__1"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__Group_2__1__Impl"
|
|
// InternalRDL.g:4316:1: rule__Instantiation__Group_2__1__Impl : ( ( rule__Instantiation__ComponentInstancesAssignment_2_1 ) ) ;
|
|
public final void rule__Instantiation__Group_2__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4320:1: ( ( ( rule__Instantiation__ComponentInstancesAssignment_2_1 ) ) )
|
|
// InternalRDL.g:4321:1: ( ( rule__Instantiation__ComponentInstancesAssignment_2_1 ) )
|
|
{
|
|
// InternalRDL.g:4321:1: ( ( rule__Instantiation__ComponentInstancesAssignment_2_1 ) )
|
|
// InternalRDL.g:4322:2: ( rule__Instantiation__ComponentInstancesAssignment_2_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getComponentInstancesAssignment_2_1());
|
|
}
|
|
// InternalRDL.g:4323:2: ( rule__Instantiation__ComponentInstancesAssignment_2_1 )
|
|
// InternalRDL.g:4323:3: rule__Instantiation__ComponentInstancesAssignment_2_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Instantiation__ComponentInstancesAssignment_2_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getComponentInstancesAssignment_2_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__Group_2__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__0"
|
|
// InternalRDL.g:4332:1: rule__ComponentInstance__Group__0 : rule__ComponentInstance__Group__0__Impl rule__ComponentInstance__Group__1 ;
|
|
public final void rule__ComponentInstance__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4336:1: ( rule__ComponentInstance__Group__0__Impl rule__ComponentInstance__Group__1 )
|
|
// InternalRDL.g:4337:2: rule__ComponentInstance__Group__0__Impl rule__ComponentInstance__Group__1
|
|
{
|
|
pushFollow(FOLLOW_26);
|
|
rule__ComponentInstance__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__0__Impl"
|
|
// InternalRDL.g:4344:1: rule__ComponentInstance__Group__0__Impl : ( ( rule__ComponentInstance__NameAssignment_0 ) ) ;
|
|
public final void rule__ComponentInstance__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4348:1: ( ( ( rule__ComponentInstance__NameAssignment_0 ) ) )
|
|
// InternalRDL.g:4349:1: ( ( rule__ComponentInstance__NameAssignment_0 ) )
|
|
{
|
|
// InternalRDL.g:4349:1: ( ( rule__ComponentInstance__NameAssignment_0 ) )
|
|
// InternalRDL.g:4350:2: ( rule__ComponentInstance__NameAssignment_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getNameAssignment_0());
|
|
}
|
|
// InternalRDL.g:4351:2: ( rule__ComponentInstance__NameAssignment_0 )
|
|
// InternalRDL.g:4351:3: rule__ComponentInstance__NameAssignment_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__NameAssignment_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getNameAssignment_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__1"
|
|
// InternalRDL.g:4359:1: rule__ComponentInstance__Group__1 : rule__ComponentInstance__Group__1__Impl rule__ComponentInstance__Group__2 ;
|
|
public final void rule__ComponentInstance__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4363:1: ( rule__ComponentInstance__Group__1__Impl rule__ComponentInstance__Group__2 )
|
|
// InternalRDL.g:4364:2: rule__ComponentInstance__Group__1__Impl rule__ComponentInstance__Group__2
|
|
{
|
|
pushFollow(FOLLOW_26);
|
|
rule__ComponentInstance__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__1__Impl"
|
|
// InternalRDL.g:4371:1: rule__ComponentInstance__Group__1__Impl : ( ( rule__ComponentInstance__RangeAssignment_1 )? ) ;
|
|
public final void rule__ComponentInstance__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4375:1: ( ( ( rule__ComponentInstance__RangeAssignment_1 )? ) )
|
|
// InternalRDL.g:4376:1: ( ( rule__ComponentInstance__RangeAssignment_1 )? )
|
|
{
|
|
// InternalRDL.g:4376:1: ( ( rule__ComponentInstance__RangeAssignment_1 )? )
|
|
// InternalRDL.g:4377:2: ( rule__ComponentInstance__RangeAssignment_1 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getRangeAssignment_1());
|
|
}
|
|
// InternalRDL.g:4378:2: ( rule__ComponentInstance__RangeAssignment_1 )?
|
|
int alt36=2;
|
|
int LA36_0 = input.LA(1);
|
|
|
|
if ( (LA36_0==128) ) {
|
|
alt36=1;
|
|
}
|
|
switch (alt36) {
|
|
case 1 :
|
|
// InternalRDL.g:4378:3: rule__ComponentInstance__RangeAssignment_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__RangeAssignment_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getRangeAssignment_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__2"
|
|
// InternalRDL.g:4386:1: rule__ComponentInstance__Group__2 : rule__ComponentInstance__Group__2__Impl rule__ComponentInstance__Group__3 ;
|
|
public final void rule__ComponentInstance__Group__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4390:1: ( rule__ComponentInstance__Group__2__Impl rule__ComponentInstance__Group__3 )
|
|
// InternalRDL.g:4391:2: rule__ComponentInstance__Group__2__Impl rule__ComponentInstance__Group__3
|
|
{
|
|
pushFollow(FOLLOW_26);
|
|
rule__ComponentInstance__Group__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__2"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__2__Impl"
|
|
// InternalRDL.g:4398:1: rule__ComponentInstance__Group__2__Impl : ( ( rule__ComponentInstance__Group_2__0 )? ) ;
|
|
public final void rule__ComponentInstance__Group__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4402:1: ( ( ( rule__ComponentInstance__Group_2__0 )? ) )
|
|
// InternalRDL.g:4403:1: ( ( rule__ComponentInstance__Group_2__0 )? )
|
|
{
|
|
// InternalRDL.g:4403:1: ( ( rule__ComponentInstance__Group_2__0 )? )
|
|
// InternalRDL.g:4404:2: ( rule__ComponentInstance__Group_2__0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getGroup_2());
|
|
}
|
|
// InternalRDL.g:4405:2: ( rule__ComponentInstance__Group_2__0 )?
|
|
int alt37=2;
|
|
int LA37_0 = input.LA(1);
|
|
|
|
if ( (LA37_0==119) ) {
|
|
alt37=1;
|
|
}
|
|
switch (alt37) {
|
|
case 1 :
|
|
// InternalRDL.g:4405:3: rule__ComponentInstance__Group_2__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group_2__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getGroup_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__3"
|
|
// InternalRDL.g:4413:1: rule__ComponentInstance__Group__3 : rule__ComponentInstance__Group__3__Impl rule__ComponentInstance__Group__4 ;
|
|
public final void rule__ComponentInstance__Group__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4417:1: ( rule__ComponentInstance__Group__3__Impl rule__ComponentInstance__Group__4 )
|
|
// InternalRDL.g:4418:2: rule__ComponentInstance__Group__3__Impl rule__ComponentInstance__Group__4
|
|
{
|
|
pushFollow(FOLLOW_26);
|
|
rule__ComponentInstance__Group__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group__4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__3"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__3__Impl"
|
|
// InternalRDL.g:4425:1: rule__ComponentInstance__Group__3__Impl : ( ( rule__ComponentInstance__Group_3__0 )? ) ;
|
|
public final void rule__ComponentInstance__Group__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4429:1: ( ( ( rule__ComponentInstance__Group_3__0 )? ) )
|
|
// InternalRDL.g:4430:1: ( ( rule__ComponentInstance__Group_3__0 )? )
|
|
{
|
|
// InternalRDL.g:4430:1: ( ( rule__ComponentInstance__Group_3__0 )? )
|
|
// InternalRDL.g:4431:2: ( rule__ComponentInstance__Group_3__0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getGroup_3());
|
|
}
|
|
// InternalRDL.g:4432:2: ( rule__ComponentInstance__Group_3__0 )?
|
|
int alt38=2;
|
|
int LA38_0 = input.LA(1);
|
|
|
|
if ( (LA38_0==125) ) {
|
|
alt38=1;
|
|
}
|
|
switch (alt38) {
|
|
case 1 :
|
|
// InternalRDL.g:4432:3: rule__ComponentInstance__Group_3__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group_3__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getGroup_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__4"
|
|
// InternalRDL.g:4440:1: rule__ComponentInstance__Group__4 : rule__ComponentInstance__Group__4__Impl rule__ComponentInstance__Group__5 ;
|
|
public final void rule__ComponentInstance__Group__4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4444:1: ( rule__ComponentInstance__Group__4__Impl rule__ComponentInstance__Group__5 )
|
|
// InternalRDL.g:4445:2: rule__ComponentInstance__Group__4__Impl rule__ComponentInstance__Group__5
|
|
{
|
|
pushFollow(FOLLOW_26);
|
|
rule__ComponentInstance__Group__4__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group__5();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__4"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__4__Impl"
|
|
// InternalRDL.g:4452:1: rule__ComponentInstance__Group__4__Impl : ( ( rule__ComponentInstance__Group_4__0 )? ) ;
|
|
public final void rule__ComponentInstance__Group__4__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4456:1: ( ( ( rule__ComponentInstance__Group_4__0 )? ) )
|
|
// InternalRDL.g:4457:1: ( ( rule__ComponentInstance__Group_4__0 )? )
|
|
{
|
|
// InternalRDL.g:4457:1: ( ( rule__ComponentInstance__Group_4__0 )? )
|
|
// InternalRDL.g:4458:2: ( rule__ComponentInstance__Group_4__0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getGroup_4());
|
|
}
|
|
// InternalRDL.g:4459:2: ( rule__ComponentInstance__Group_4__0 )?
|
|
int alt39=2;
|
|
int LA39_0 = input.LA(1);
|
|
|
|
if ( (LA39_0==126) ) {
|
|
alt39=1;
|
|
}
|
|
switch (alt39) {
|
|
case 1 :
|
|
// InternalRDL.g:4459:3: rule__ComponentInstance__Group_4__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group_4__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getGroup_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__4__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__5"
|
|
// InternalRDL.g:4467:1: rule__ComponentInstance__Group__5 : rule__ComponentInstance__Group__5__Impl ;
|
|
public final void rule__ComponentInstance__Group__5() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4471:1: ( rule__ComponentInstance__Group__5__Impl )
|
|
// InternalRDL.g:4472:2: rule__ComponentInstance__Group__5__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group__5__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__5"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group__5__Impl"
|
|
// InternalRDL.g:4478:1: rule__ComponentInstance__Group__5__Impl : ( ( rule__ComponentInstance__Group_5__0 )? ) ;
|
|
public final void rule__ComponentInstance__Group__5__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4482:1: ( ( ( rule__ComponentInstance__Group_5__0 )? ) )
|
|
// InternalRDL.g:4483:1: ( ( rule__ComponentInstance__Group_5__0 )? )
|
|
{
|
|
// InternalRDL.g:4483:1: ( ( rule__ComponentInstance__Group_5__0 )? )
|
|
// InternalRDL.g:4484:2: ( rule__ComponentInstance__Group_5__0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getGroup_5());
|
|
}
|
|
// InternalRDL.g:4485:2: ( rule__ComponentInstance__Group_5__0 )?
|
|
int alt40=2;
|
|
int LA40_0 = input.LA(1);
|
|
|
|
if ( (LA40_0==127) ) {
|
|
alt40=1;
|
|
}
|
|
switch (alt40) {
|
|
case 1 :
|
|
// InternalRDL.g:4485:3: rule__ComponentInstance__Group_5__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group_5__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getGroup_5());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group__5__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_2__0"
|
|
// InternalRDL.g:4494:1: rule__ComponentInstance__Group_2__0 : rule__ComponentInstance__Group_2__0__Impl rule__ComponentInstance__Group_2__1 ;
|
|
public final void rule__ComponentInstance__Group_2__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4498:1: ( rule__ComponentInstance__Group_2__0__Impl rule__ComponentInstance__Group_2__1 )
|
|
// InternalRDL.g:4499:2: rule__ComponentInstance__Group_2__0__Impl rule__ComponentInstance__Group_2__1
|
|
{
|
|
pushFollow(FOLLOW_27);
|
|
rule__ComponentInstance__Group_2__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group_2__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_2__0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_2__0__Impl"
|
|
// InternalRDL.g:4506:1: rule__ComponentInstance__Group_2__0__Impl : ( '=' ) ;
|
|
public final void rule__ComponentInstance__Group_2__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4510:1: ( ( '=' ) )
|
|
// InternalRDL.g:4511:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:4511:1: ( '=' )
|
|
// InternalRDL.g:4512:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getEqualsSignKeyword_2_0());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getEqualsSignKeyword_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_2__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_2__1"
|
|
// InternalRDL.g:4521:1: rule__ComponentInstance__Group_2__1 : rule__ComponentInstance__Group_2__1__Impl ;
|
|
public final void rule__ComponentInstance__Group_2__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4525:1: ( rule__ComponentInstance__Group_2__1__Impl )
|
|
// InternalRDL.g:4526:2: rule__ComponentInstance__Group_2__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__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__ComponentInstance__Group_2__1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_2__1__Impl"
|
|
// InternalRDL.g:4532:1: rule__ComponentInstance__Group_2__1__Impl : ( ( rule__ComponentInstance__ResetAssignment_2_1 ) ) ;
|
|
public final void rule__ComponentInstance__Group_2__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4536:1: ( ( ( rule__ComponentInstance__ResetAssignment_2_1 ) ) )
|
|
// InternalRDL.g:4537:1: ( ( rule__ComponentInstance__ResetAssignment_2_1 ) )
|
|
{
|
|
// InternalRDL.g:4537:1: ( ( rule__ComponentInstance__ResetAssignment_2_1 ) )
|
|
// InternalRDL.g:4538:2: ( rule__ComponentInstance__ResetAssignment_2_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getResetAssignment_2_1());
|
|
}
|
|
// InternalRDL.g:4539:2: ( rule__ComponentInstance__ResetAssignment_2_1 )
|
|
// InternalRDL.g:4539:3: rule__ComponentInstance__ResetAssignment_2_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__ResetAssignment_2_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getResetAssignment_2_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_2__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_3__0"
|
|
// InternalRDL.g:4548:1: rule__ComponentInstance__Group_3__0 : rule__ComponentInstance__Group_3__0__Impl rule__ComponentInstance__Group_3__1 ;
|
|
public final void rule__ComponentInstance__Group_3__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4552:1: ( rule__ComponentInstance__Group_3__0__Impl rule__ComponentInstance__Group_3__1 )
|
|
// InternalRDL.g:4553:2: rule__ComponentInstance__Group_3__0__Impl rule__ComponentInstance__Group_3__1
|
|
{
|
|
pushFollow(FOLLOW_27);
|
|
rule__ComponentInstance__Group_3__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group_3__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_3__0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_3__0__Impl"
|
|
// InternalRDL.g:4560:1: rule__ComponentInstance__Group_3__0__Impl : ( '@' ) ;
|
|
public final void rule__ComponentInstance__Group_3__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4564:1: ( ( '@' ) )
|
|
// InternalRDL.g:4565:1: ( '@' )
|
|
{
|
|
// InternalRDL.g:4565:1: ( '@' )
|
|
// InternalRDL.g:4566:2: '@'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getCommercialAtKeyword_3_0());
|
|
}
|
|
match(input,125,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getCommercialAtKeyword_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_3__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_3__1"
|
|
// InternalRDL.g:4575:1: rule__ComponentInstance__Group_3__1 : rule__ComponentInstance__Group_3__1__Impl ;
|
|
public final void rule__ComponentInstance__Group_3__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4579:1: ( rule__ComponentInstance__Group_3__1__Impl )
|
|
// InternalRDL.g:4580:2: rule__ComponentInstance__Group_3__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group_3__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_3__1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_3__1__Impl"
|
|
// InternalRDL.g:4586:1: rule__ComponentInstance__Group_3__1__Impl : ( ( rule__ComponentInstance__AddressAssignment_3_1 ) ) ;
|
|
public final void rule__ComponentInstance__Group_3__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4590:1: ( ( ( rule__ComponentInstance__AddressAssignment_3_1 ) ) )
|
|
// InternalRDL.g:4591:1: ( ( rule__ComponentInstance__AddressAssignment_3_1 ) )
|
|
{
|
|
// InternalRDL.g:4591:1: ( ( rule__ComponentInstance__AddressAssignment_3_1 ) )
|
|
// InternalRDL.g:4592:2: ( rule__ComponentInstance__AddressAssignment_3_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getAddressAssignment_3_1());
|
|
}
|
|
// InternalRDL.g:4593:2: ( rule__ComponentInstance__AddressAssignment_3_1 )
|
|
// InternalRDL.g:4593:3: rule__ComponentInstance__AddressAssignment_3_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__AddressAssignment_3_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getAddressAssignment_3_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_3__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_4__0"
|
|
// InternalRDL.g:4602:1: rule__ComponentInstance__Group_4__0 : rule__ComponentInstance__Group_4__0__Impl rule__ComponentInstance__Group_4__1 ;
|
|
public final void rule__ComponentInstance__Group_4__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4606:1: ( rule__ComponentInstance__Group_4__0__Impl rule__ComponentInstance__Group_4__1 )
|
|
// InternalRDL.g:4607:2: rule__ComponentInstance__Group_4__0__Impl rule__ComponentInstance__Group_4__1
|
|
{
|
|
pushFollow(FOLLOW_27);
|
|
rule__ComponentInstance__Group_4__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group_4__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_4__0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_4__0__Impl"
|
|
// InternalRDL.g:4614:1: rule__ComponentInstance__Group_4__0__Impl : ( '+=' ) ;
|
|
public final void rule__ComponentInstance__Group_4__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4618:1: ( ( '+=' ) )
|
|
// InternalRDL.g:4619:1: ( '+=' )
|
|
{
|
|
// InternalRDL.g:4619:1: ( '+=' )
|
|
// InternalRDL.g:4620:2: '+='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getPlusSignEqualsSignKeyword_4_0());
|
|
}
|
|
match(input,126,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getPlusSignEqualsSignKeyword_4_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_4__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_4__1"
|
|
// InternalRDL.g:4629:1: rule__ComponentInstance__Group_4__1 : rule__ComponentInstance__Group_4__1__Impl ;
|
|
public final void rule__ComponentInstance__Group_4__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4633:1: ( rule__ComponentInstance__Group_4__1__Impl )
|
|
// InternalRDL.g:4634:2: rule__ComponentInstance__Group_4__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__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__ComponentInstance__Group_4__1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_4__1__Impl"
|
|
// InternalRDL.g:4640:1: rule__ComponentInstance__Group_4__1__Impl : ( ( rule__ComponentInstance__AddrIncAssignment_4_1 ) ) ;
|
|
public final void rule__ComponentInstance__Group_4__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4644:1: ( ( ( rule__ComponentInstance__AddrIncAssignment_4_1 ) ) )
|
|
// InternalRDL.g:4645:1: ( ( rule__ComponentInstance__AddrIncAssignment_4_1 ) )
|
|
{
|
|
// InternalRDL.g:4645:1: ( ( rule__ComponentInstance__AddrIncAssignment_4_1 ) )
|
|
// InternalRDL.g:4646:2: ( rule__ComponentInstance__AddrIncAssignment_4_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getAddrIncAssignment_4_1());
|
|
}
|
|
// InternalRDL.g:4647:2: ( rule__ComponentInstance__AddrIncAssignment_4_1 )
|
|
// InternalRDL.g:4647:3: rule__ComponentInstance__AddrIncAssignment_4_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__AddrIncAssignment_4_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getAddrIncAssignment_4_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_4__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_5__0"
|
|
// InternalRDL.g:4656:1: rule__ComponentInstance__Group_5__0 : rule__ComponentInstance__Group_5__0__Impl rule__ComponentInstance__Group_5__1 ;
|
|
public final void rule__ComponentInstance__Group_5__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4660:1: ( rule__ComponentInstance__Group_5__0__Impl rule__ComponentInstance__Group_5__1 )
|
|
// InternalRDL.g:4661:2: rule__ComponentInstance__Group_5__0__Impl rule__ComponentInstance__Group_5__1
|
|
{
|
|
pushFollow(FOLLOW_27);
|
|
rule__ComponentInstance__Group_5__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group_5__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_5__0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_5__0__Impl"
|
|
// InternalRDL.g:4668:1: rule__ComponentInstance__Group_5__0__Impl : ( '%=' ) ;
|
|
public final void rule__ComponentInstance__Group_5__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4672:1: ( ( '%=' ) )
|
|
// InternalRDL.g:4673:1: ( '%=' )
|
|
{
|
|
// InternalRDL.g:4673:1: ( '%=' )
|
|
// InternalRDL.g:4674:2: '%='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getPercentSignEqualsSignKeyword_5_0());
|
|
}
|
|
match(input,127,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getPercentSignEqualsSignKeyword_5_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_5__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_5__1"
|
|
// InternalRDL.g:4683:1: rule__ComponentInstance__Group_5__1 : rule__ComponentInstance__Group_5__1__Impl ;
|
|
public final void rule__ComponentInstance__Group_5__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4687:1: ( rule__ComponentInstance__Group_5__1__Impl )
|
|
// InternalRDL.g:4688:2: rule__ComponentInstance__Group_5__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__Group_5__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_5__1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__Group_5__1__Impl"
|
|
// InternalRDL.g:4694:1: rule__ComponentInstance__Group_5__1__Impl : ( ( rule__ComponentInstance__AddrModAssignment_5_1 ) ) ;
|
|
public final void rule__ComponentInstance__Group_5__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4698:1: ( ( ( rule__ComponentInstance__AddrModAssignment_5_1 ) ) )
|
|
// InternalRDL.g:4699:1: ( ( rule__ComponentInstance__AddrModAssignment_5_1 ) )
|
|
{
|
|
// InternalRDL.g:4699:1: ( ( rule__ComponentInstance__AddrModAssignment_5_1 ) )
|
|
// InternalRDL.g:4700:2: ( rule__ComponentInstance__AddrModAssignment_5_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getAddrModAssignment_5_1());
|
|
}
|
|
// InternalRDL.g:4701:2: ( rule__ComponentInstance__AddrModAssignment_5_1 )
|
|
// InternalRDL.g:4701:3: rule__ComponentInstance__AddrModAssignment_5_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentInstance__AddrModAssignment_5_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getAddrModAssignment_5_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__Group_5__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group__0"
|
|
// InternalRDL.g:4710:1: rule__Range__Group__0 : rule__Range__Group__0__Impl rule__Range__Group__1 ;
|
|
public final void rule__Range__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4714:1: ( rule__Range__Group__0__Impl rule__Range__Group__1 )
|
|
// InternalRDL.g:4715:2: rule__Range__Group__0__Impl rule__Range__Group__1
|
|
{
|
|
pushFollow(FOLLOW_27);
|
|
rule__Range__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group__0__Impl"
|
|
// InternalRDL.g:4722:1: rule__Range__Group__0__Impl : ( '[' ) ;
|
|
public final void rule__Range__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4726:1: ( ( '[' ) )
|
|
// InternalRDL.g:4727:1: ( '[' )
|
|
{
|
|
// InternalRDL.g:4727:1: ( '[' )
|
|
// InternalRDL.g:4728:2: '['
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getLeftSquareBracketKeyword_0());
|
|
}
|
|
match(input,128,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getLeftSquareBracketKeyword_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group__1"
|
|
// InternalRDL.g:4737:1: rule__Range__Group__1 : rule__Range__Group__1__Impl rule__Range__Group__2 ;
|
|
public final void rule__Range__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4741:1: ( rule__Range__Group__1__Impl rule__Range__Group__2 )
|
|
// InternalRDL.g:4742:2: rule__Range__Group__1__Impl rule__Range__Group__2
|
|
{
|
|
pushFollow(FOLLOW_28);
|
|
rule__Range__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__Group__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group__1__Impl"
|
|
// InternalRDL.g:4749:1: rule__Range__Group__1__Impl : ( ( rule__Range__Alternatives_1 ) ) ;
|
|
public final void rule__Range__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4753:1: ( ( ( rule__Range__Alternatives_1 ) ) )
|
|
// InternalRDL.g:4754:1: ( ( rule__Range__Alternatives_1 ) )
|
|
{
|
|
// InternalRDL.g:4754:1: ( ( rule__Range__Alternatives_1 ) )
|
|
// InternalRDL.g:4755:2: ( rule__Range__Alternatives_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getAlternatives_1());
|
|
}
|
|
// InternalRDL.g:4756:2: ( rule__Range__Alternatives_1 )
|
|
// InternalRDL.g:4756:3: rule__Range__Alternatives_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__Alternatives_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getAlternatives_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group__2"
|
|
// InternalRDL.g:4764:1: rule__Range__Group__2 : rule__Range__Group__2__Impl ;
|
|
public final void rule__Range__Group__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4768:1: ( rule__Range__Group__2__Impl )
|
|
// InternalRDL.g:4769:2: rule__Range__Group__2__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__Group__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__Group__2"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group__2__Impl"
|
|
// InternalRDL.g:4775:1: rule__Range__Group__2__Impl : ( ']' ) ;
|
|
public final void rule__Range__Group__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4779:1: ( ( ']' ) )
|
|
// InternalRDL.g:4780:1: ( ']' )
|
|
{
|
|
// InternalRDL.g:4780:1: ( ']' )
|
|
// InternalRDL.g:4781:2: ']'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getRightSquareBracketKeyword_2());
|
|
}
|
|
match(input,129,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getRightSquareBracketKeyword_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__Group__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group_1_0__0"
|
|
// InternalRDL.g:4791:1: rule__Range__Group_1_0__0 : rule__Range__Group_1_0__0__Impl rule__Range__Group_1_0__1 ;
|
|
public final void rule__Range__Group_1_0__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4795:1: ( rule__Range__Group_1_0__0__Impl rule__Range__Group_1_0__1 )
|
|
// InternalRDL.g:4796:2: rule__Range__Group_1_0__0__Impl rule__Range__Group_1_0__1
|
|
{
|
|
pushFollow(FOLLOW_29);
|
|
rule__Range__Group_1_0__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__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__Range__Group_1_0__0"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group_1_0__0__Impl"
|
|
// InternalRDL.g:4803:1: rule__Range__Group_1_0__0__Impl : ( ( rule__Range__LeftAssignment_1_0_0 ) ) ;
|
|
public final void rule__Range__Group_1_0__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4807:1: ( ( ( rule__Range__LeftAssignment_1_0_0 ) ) )
|
|
// InternalRDL.g:4808:1: ( ( rule__Range__LeftAssignment_1_0_0 ) )
|
|
{
|
|
// InternalRDL.g:4808:1: ( ( rule__Range__LeftAssignment_1_0_0 ) )
|
|
// InternalRDL.g:4809:2: ( rule__Range__LeftAssignment_1_0_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getLeftAssignment_1_0_0());
|
|
}
|
|
// InternalRDL.g:4810:2: ( rule__Range__LeftAssignment_1_0_0 )
|
|
// InternalRDL.g:4810:3: rule__Range__LeftAssignment_1_0_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__LeftAssignment_1_0_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getLeftAssignment_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__Group_1_0__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group_1_0__1"
|
|
// InternalRDL.g:4818:1: rule__Range__Group_1_0__1 : rule__Range__Group_1_0__1__Impl rule__Range__Group_1_0__2 ;
|
|
public final void rule__Range__Group_1_0__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4822:1: ( rule__Range__Group_1_0__1__Impl rule__Range__Group_1_0__2 )
|
|
// InternalRDL.g:4823:2: rule__Range__Group_1_0__1__Impl rule__Range__Group_1_0__2
|
|
{
|
|
pushFollow(FOLLOW_27);
|
|
rule__Range__Group_1_0__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__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__Range__Group_1_0__1"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group_1_0__1__Impl"
|
|
// InternalRDL.g:4830:1: rule__Range__Group_1_0__1__Impl : ( ':' ) ;
|
|
public final void rule__Range__Group_1_0__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4834:1: ( ( ':' ) )
|
|
// InternalRDL.g:4835:1: ( ':' )
|
|
{
|
|
// InternalRDL.g:4835:1: ( ':' )
|
|
// InternalRDL.g:4836:2: ':'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getColonKeyword_1_0_1());
|
|
}
|
|
match(input,130,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getColonKeyword_1_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__Group_1_0__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group_1_0__2"
|
|
// InternalRDL.g:4845:1: rule__Range__Group_1_0__2 : rule__Range__Group_1_0__2__Impl ;
|
|
public final void rule__Range__Group_1_0__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4849:1: ( rule__Range__Group_1_0__2__Impl )
|
|
// InternalRDL.g:4850:2: rule__Range__Group_1_0__2__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__Group_1_0__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__Group_1_0__2"
|
|
|
|
|
|
// $ANTLR start "rule__Range__Group_1_0__2__Impl"
|
|
// InternalRDL.g:4856:1: rule__Range__Group_1_0__2__Impl : ( ( rule__Range__RightAssignment_1_0_2 ) ) ;
|
|
public final void rule__Range__Group_1_0__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4860:1: ( ( ( rule__Range__RightAssignment_1_0_2 ) ) )
|
|
// InternalRDL.g:4861:1: ( ( rule__Range__RightAssignment_1_0_2 ) )
|
|
{
|
|
// InternalRDL.g:4861:1: ( ( rule__Range__RightAssignment_1_0_2 ) )
|
|
// InternalRDL.g:4862:2: ( rule__Range__RightAssignment_1_0_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getRightAssignment_1_0_2());
|
|
}
|
|
// InternalRDL.g:4863:2: ( rule__Range__RightAssignment_1_0_2 )
|
|
// InternalRDL.g:4863:3: rule__Range__RightAssignment_1_0_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Range__RightAssignment_1_0_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getRightAssignment_1_0_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__Group_1_0__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__DefaultProperyAssignment__Group__0"
|
|
// InternalRDL.g:4872:1: rule__DefaultProperyAssignment__Group__0 : rule__DefaultProperyAssignment__Group__0__Impl rule__DefaultProperyAssignment__Group__1 ;
|
|
public final void rule__DefaultProperyAssignment__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4876:1: ( rule__DefaultProperyAssignment__Group__0__Impl rule__DefaultProperyAssignment__Group__1 )
|
|
// InternalRDL.g:4877:2: rule__DefaultProperyAssignment__Group__0__Impl rule__DefaultProperyAssignment__Group__1
|
|
{
|
|
pushFollow(FOLLOW_30);
|
|
rule__DefaultProperyAssignment__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__DefaultProperyAssignment__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__DefaultProperyAssignment__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__DefaultProperyAssignment__Group__0__Impl"
|
|
// InternalRDL.g:4884:1: rule__DefaultProperyAssignment__Group__0__Impl : ( 'default' ) ;
|
|
public final void rule__DefaultProperyAssignment__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4888:1: ( ( 'default' ) )
|
|
// InternalRDL.g:4889:1: ( 'default' )
|
|
{
|
|
// InternalRDL.g:4889:1: ( 'default' )
|
|
// InternalRDL.g:4890:2: 'default'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getDefaultProperyAssignmentAccess().getDefaultKeyword_0());
|
|
}
|
|
match(input,120,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getDefaultProperyAssignmentAccess().getDefaultKeyword_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__DefaultProperyAssignment__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__DefaultProperyAssignment__Group__1"
|
|
// InternalRDL.g:4899:1: rule__DefaultProperyAssignment__Group__1 : rule__DefaultProperyAssignment__Group__1__Impl ;
|
|
public final void rule__DefaultProperyAssignment__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4903:1: ( rule__DefaultProperyAssignment__Group__1__Impl )
|
|
// InternalRDL.g:4904:2: rule__DefaultProperyAssignment__Group__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__DefaultProperyAssignment__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__DefaultProperyAssignment__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__DefaultProperyAssignment__Group__1__Impl"
|
|
// InternalRDL.g:4910:1: rule__DefaultProperyAssignment__Group__1__Impl : ( ruleExplicitPropertyAssignment ) ;
|
|
public final void rule__DefaultProperyAssignment__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4914:1: ( ( ruleExplicitPropertyAssignment ) )
|
|
// InternalRDL.g:4915:1: ( ruleExplicitPropertyAssignment )
|
|
{
|
|
// InternalRDL.g:4915:1: ( ruleExplicitPropertyAssignment )
|
|
// InternalRDL.g:4916:2: ruleExplicitPropertyAssignment
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getDefaultProperyAssignmentAccess().getExplicitPropertyAssignmentParserRuleCall_1());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleExplicitPropertyAssignment();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getDefaultProperyAssignmentAccess().getExplicitPropertyAssignmentParserRuleCall_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__DefaultProperyAssignment__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_0__0"
|
|
// InternalRDL.g:4926:1: rule__ExplicitPropertyAssignment__Group_0__0 : rule__ExplicitPropertyAssignment__Group_0__0__Impl rule__ExplicitPropertyAssignment__Group_0__1 ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_0__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4930:1: ( rule__ExplicitPropertyAssignment__Group_0__0__Impl rule__ExplicitPropertyAssignment__Group_0__1 )
|
|
// InternalRDL.g:4931:2: rule__ExplicitPropertyAssignment__Group_0__0__Impl rule__ExplicitPropertyAssignment__Group_0__1
|
|
{
|
|
pushFollow(FOLLOW_30);
|
|
rule__ExplicitPropertyAssignment__Group_0__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__Group_0__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__Group_0__0"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_0__0__Impl"
|
|
// InternalRDL.g:4938:1: rule__ExplicitPropertyAssignment__Group_0__0__Impl : ( ( rule__ExplicitPropertyAssignment__ModifierAssignment_0_0 ) ) ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_0__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4942:1: ( ( ( rule__ExplicitPropertyAssignment__ModifierAssignment_0_0 ) ) )
|
|
// InternalRDL.g:4943:1: ( ( rule__ExplicitPropertyAssignment__ModifierAssignment_0_0 ) )
|
|
{
|
|
// InternalRDL.g:4943:1: ( ( rule__ExplicitPropertyAssignment__ModifierAssignment_0_0 ) )
|
|
// InternalRDL.g:4944:2: ( rule__ExplicitPropertyAssignment__ModifierAssignment_0_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getModifierAssignment_0_0());
|
|
}
|
|
// InternalRDL.g:4945:2: ( rule__ExplicitPropertyAssignment__ModifierAssignment_0_0 )
|
|
// InternalRDL.g:4945:3: rule__ExplicitPropertyAssignment__ModifierAssignment_0_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__ModifierAssignment_0_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getModifierAssignment_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__Group_0__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_0__1"
|
|
// InternalRDL.g:4953:1: rule__ExplicitPropertyAssignment__Group_0__1 : rule__ExplicitPropertyAssignment__Group_0__1__Impl ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_0__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4957:1: ( rule__ExplicitPropertyAssignment__Group_0__1__Impl )
|
|
// InternalRDL.g:4958:2: rule__ExplicitPropertyAssignment__Group_0__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__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__ExplicitPropertyAssignment__Group_0__1"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_0__1__Impl"
|
|
// InternalRDL.g:4964:1: rule__ExplicitPropertyAssignment__Group_0__1__Impl : ( ( rule__ExplicitPropertyAssignment__NameAssignment_0_1 ) ) ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_0__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4968:1: ( ( ( rule__ExplicitPropertyAssignment__NameAssignment_0_1 ) ) )
|
|
// InternalRDL.g:4969:1: ( ( rule__ExplicitPropertyAssignment__NameAssignment_0_1 ) )
|
|
{
|
|
// InternalRDL.g:4969:1: ( ( rule__ExplicitPropertyAssignment__NameAssignment_0_1 ) )
|
|
// InternalRDL.g:4970:2: ( rule__ExplicitPropertyAssignment__NameAssignment_0_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getNameAssignment_0_1());
|
|
}
|
|
// InternalRDL.g:4971:2: ( rule__ExplicitPropertyAssignment__NameAssignment_0_1 )
|
|
// InternalRDL.g:4971:3: rule__ExplicitPropertyAssignment__NameAssignment_0_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__NameAssignment_0_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getNameAssignment_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__Group_0__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_1__0"
|
|
// InternalRDL.g:4980:1: rule__ExplicitPropertyAssignment__Group_1__0 : rule__ExplicitPropertyAssignment__Group_1__0__Impl rule__ExplicitPropertyAssignment__Group_1__1 ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4984:1: ( rule__ExplicitPropertyAssignment__Group_1__0__Impl rule__ExplicitPropertyAssignment__Group_1__1 )
|
|
// InternalRDL.g:4985:2: rule__ExplicitPropertyAssignment__Group_1__0__Impl rule__ExplicitPropertyAssignment__Group_1__1
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__ExplicitPropertyAssignment__Group_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__Group_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__Group_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_1__0__Impl"
|
|
// InternalRDL.g:4992:1: rule__ExplicitPropertyAssignment__Group_1__0__Impl : ( ( rule__ExplicitPropertyAssignment__NameAssignment_1_0 ) ) ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:4996:1: ( ( ( rule__ExplicitPropertyAssignment__NameAssignment_1_0 ) ) )
|
|
// InternalRDL.g:4997:1: ( ( rule__ExplicitPropertyAssignment__NameAssignment_1_0 ) )
|
|
{
|
|
// InternalRDL.g:4997:1: ( ( rule__ExplicitPropertyAssignment__NameAssignment_1_0 ) )
|
|
// InternalRDL.g:4998:2: ( rule__ExplicitPropertyAssignment__NameAssignment_1_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getNameAssignment_1_0());
|
|
}
|
|
// InternalRDL.g:4999:2: ( rule__ExplicitPropertyAssignment__NameAssignment_1_0 )
|
|
// InternalRDL.g:4999:3: rule__ExplicitPropertyAssignment__NameAssignment_1_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__NameAssignment_1_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getNameAssignment_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__Group_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_1__1"
|
|
// InternalRDL.g:5007:1: rule__ExplicitPropertyAssignment__Group_1__1 : rule__ExplicitPropertyAssignment__Group_1__1__Impl ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5011:1: ( rule__ExplicitPropertyAssignment__Group_1__1__Impl )
|
|
// InternalRDL.g:5012:2: rule__ExplicitPropertyAssignment__Group_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__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__ExplicitPropertyAssignment__Group_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_1__1__Impl"
|
|
// InternalRDL.g:5018:1: rule__ExplicitPropertyAssignment__Group_1__1__Impl : ( ( rule__ExplicitPropertyAssignment__Group_1_1__0 )? ) ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5022:1: ( ( ( rule__ExplicitPropertyAssignment__Group_1_1__0 )? ) )
|
|
// InternalRDL.g:5023:1: ( ( rule__ExplicitPropertyAssignment__Group_1_1__0 )? )
|
|
{
|
|
// InternalRDL.g:5023:1: ( ( rule__ExplicitPropertyAssignment__Group_1_1__0 )? )
|
|
// InternalRDL.g:5024:2: ( rule__ExplicitPropertyAssignment__Group_1_1__0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getGroup_1_1());
|
|
}
|
|
// InternalRDL.g:5025:2: ( rule__ExplicitPropertyAssignment__Group_1_1__0 )?
|
|
int alt41=2;
|
|
int LA41_0 = input.LA(1);
|
|
|
|
if ( (LA41_0==119) ) {
|
|
alt41=1;
|
|
}
|
|
switch (alt41) {
|
|
case 1 :
|
|
// InternalRDL.g:5025:3: rule__ExplicitPropertyAssignment__Group_1_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__Group_1_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getGroup_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__Group_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_1_1__0"
|
|
// InternalRDL.g:5034:1: rule__ExplicitPropertyAssignment__Group_1_1__0 : rule__ExplicitPropertyAssignment__Group_1_1__0__Impl rule__ExplicitPropertyAssignment__Group_1_1__1 ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_1_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5038:1: ( rule__ExplicitPropertyAssignment__Group_1_1__0__Impl rule__ExplicitPropertyAssignment__Group_1_1__1 )
|
|
// InternalRDL.g:5039:2: rule__ExplicitPropertyAssignment__Group_1_1__0__Impl rule__ExplicitPropertyAssignment__Group_1_1__1
|
|
{
|
|
pushFollow(FOLLOW_31);
|
|
rule__ExplicitPropertyAssignment__Group_1_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__Group_1_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__Group_1_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_1_1__0__Impl"
|
|
// InternalRDL.g:5046:1: rule__ExplicitPropertyAssignment__Group_1_1__0__Impl : ( '=' ) ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_1_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5050:1: ( ( '=' ) )
|
|
// InternalRDL.g:5051:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:5051:1: ( '=' )
|
|
// InternalRDL.g:5052:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getEqualsSignKeyword_1_1_0());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getEqualsSignKeyword_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__Group_1_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_1_1__1"
|
|
// InternalRDL.g:5061:1: rule__ExplicitPropertyAssignment__Group_1_1__1 : rule__ExplicitPropertyAssignment__Group_1_1__1__Impl ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_1_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5065:1: ( rule__ExplicitPropertyAssignment__Group_1_1__1__Impl )
|
|
// InternalRDL.g:5066:2: rule__ExplicitPropertyAssignment__Group_1_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__Group_1_1__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__Group_1_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__Group_1_1__1__Impl"
|
|
// InternalRDL.g:5072:1: rule__ExplicitPropertyAssignment__Group_1_1__1__Impl : ( ( rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1 ) ) ;
|
|
public final void rule__ExplicitPropertyAssignment__Group_1_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5076:1: ( ( ( rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1 ) ) )
|
|
// InternalRDL.g:5077:1: ( ( rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1 ) )
|
|
{
|
|
// InternalRDL.g:5077:1: ( ( rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1 ) )
|
|
// InternalRDL.g:5078:2: ( rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getRhsAssignment_1_1_1());
|
|
}
|
|
// InternalRDL.g:5079:2: ( rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1 )
|
|
// InternalRDL.g:5079:3: rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getRhsAssignment_1_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__Group_1_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group__0"
|
|
// InternalRDL.g:5088:1: rule__PostPropertyAssignment__Group__0 : rule__PostPropertyAssignment__Group__0__Impl rule__PostPropertyAssignment__Group__1 ;
|
|
public final void rule__PostPropertyAssignment__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5092:1: ( rule__PostPropertyAssignment__Group__0__Impl rule__PostPropertyAssignment__Group__1 )
|
|
// InternalRDL.g:5093:2: rule__PostPropertyAssignment__Group__0__Impl rule__PostPropertyAssignment__Group__1
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__PostPropertyAssignment__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group__0__Impl"
|
|
// InternalRDL.g:5100:1: rule__PostPropertyAssignment__Group__0__Impl : ( ( rule__PostPropertyAssignment__Alternatives_0 ) ) ;
|
|
public final void rule__PostPropertyAssignment__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5104:1: ( ( ( rule__PostPropertyAssignment__Alternatives_0 ) ) )
|
|
// InternalRDL.g:5105:1: ( ( rule__PostPropertyAssignment__Alternatives_0 ) )
|
|
{
|
|
// InternalRDL.g:5105:1: ( ( rule__PostPropertyAssignment__Alternatives_0 ) )
|
|
// InternalRDL.g:5106:2: ( rule__PostPropertyAssignment__Alternatives_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getAlternatives_0());
|
|
}
|
|
// InternalRDL.g:5107:2: ( rule__PostPropertyAssignment__Alternatives_0 )
|
|
// InternalRDL.g:5107:3: rule__PostPropertyAssignment__Alternatives_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__Alternatives_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getAlternatives_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group__1"
|
|
// InternalRDL.g:5115:1: rule__PostPropertyAssignment__Group__1 : rule__PostPropertyAssignment__Group__1__Impl ;
|
|
public final void rule__PostPropertyAssignment__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5119:1: ( rule__PostPropertyAssignment__Group__1__Impl )
|
|
// InternalRDL.g:5120:2: rule__PostPropertyAssignment__Group__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group__1__Impl"
|
|
// InternalRDL.g:5126:1: rule__PostPropertyAssignment__Group__1__Impl : ( ( rule__PostPropertyAssignment__Group_1__0 )? ) ;
|
|
public final void rule__PostPropertyAssignment__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5130:1: ( ( ( rule__PostPropertyAssignment__Group_1__0 )? ) )
|
|
// InternalRDL.g:5131:1: ( ( rule__PostPropertyAssignment__Group_1__0 )? )
|
|
{
|
|
// InternalRDL.g:5131:1: ( ( rule__PostPropertyAssignment__Group_1__0 )? )
|
|
// InternalRDL.g:5132:2: ( rule__PostPropertyAssignment__Group_1__0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getGroup_1());
|
|
}
|
|
// InternalRDL.g:5133:2: ( rule__PostPropertyAssignment__Group_1__0 )?
|
|
int alt42=2;
|
|
int LA42_0 = input.LA(1);
|
|
|
|
if ( (LA42_0==119) ) {
|
|
alt42=1;
|
|
}
|
|
switch (alt42) {
|
|
case 1 :
|
|
// InternalRDL.g:5133:3: rule__PostPropertyAssignment__Group_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__Group_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getGroup_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group_0_0__0"
|
|
// InternalRDL.g:5142:1: rule__PostPropertyAssignment__Group_0_0__0 : rule__PostPropertyAssignment__Group_0_0__0__Impl rule__PostPropertyAssignment__Group_0_0__1 ;
|
|
public final void rule__PostPropertyAssignment__Group_0_0__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5146:1: ( rule__PostPropertyAssignment__Group_0_0__0__Impl rule__PostPropertyAssignment__Group_0_0__1 )
|
|
// InternalRDL.g:5147:2: rule__PostPropertyAssignment__Group_0_0__0__Impl rule__PostPropertyAssignment__Group_0_0__1
|
|
{
|
|
pushFollow(FOLLOW_32);
|
|
rule__PostPropertyAssignment__Group_0_0__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__Group_0_0__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group_0_0__0"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group_0_0__0__Impl"
|
|
// InternalRDL.g:5154:1: rule__PostPropertyAssignment__Group_0_0__0__Impl : ( ( rule__PostPropertyAssignment__InstanceAssignment_0_0_0 ) ) ;
|
|
public final void rule__PostPropertyAssignment__Group_0_0__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5158:1: ( ( ( rule__PostPropertyAssignment__InstanceAssignment_0_0_0 ) ) )
|
|
// InternalRDL.g:5159:1: ( ( rule__PostPropertyAssignment__InstanceAssignment_0_0_0 ) )
|
|
{
|
|
// InternalRDL.g:5159:1: ( ( rule__PostPropertyAssignment__InstanceAssignment_0_0_0 ) )
|
|
// InternalRDL.g:5160:2: ( rule__PostPropertyAssignment__InstanceAssignment_0_0_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getInstanceAssignment_0_0_0());
|
|
}
|
|
// InternalRDL.g:5161:2: ( rule__PostPropertyAssignment__InstanceAssignment_0_0_0 )
|
|
// InternalRDL.g:5161:3: rule__PostPropertyAssignment__InstanceAssignment_0_0_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__InstanceAssignment_0_0_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getInstanceAssignment_0_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group_0_0__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group_0_0__1"
|
|
// InternalRDL.g:5169:1: rule__PostPropertyAssignment__Group_0_0__1 : rule__PostPropertyAssignment__Group_0_0__1__Impl rule__PostPropertyAssignment__Group_0_0__2 ;
|
|
public final void rule__PostPropertyAssignment__Group_0_0__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5173:1: ( rule__PostPropertyAssignment__Group_0_0__1__Impl rule__PostPropertyAssignment__Group_0_0__2 )
|
|
// InternalRDL.g:5174:2: rule__PostPropertyAssignment__Group_0_0__1__Impl rule__PostPropertyAssignment__Group_0_0__2
|
|
{
|
|
pushFollow(FOLLOW_33);
|
|
rule__PostPropertyAssignment__Group_0_0__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__Group_0_0__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group_0_0__1"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group_0_0__1__Impl"
|
|
// InternalRDL.g:5181:1: rule__PostPropertyAssignment__Group_0_0__1__Impl : ( '->' ) ;
|
|
public final void rule__PostPropertyAssignment__Group_0_0__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5185:1: ( ( '->' ) )
|
|
// InternalRDL.g:5186:1: ( '->' )
|
|
{
|
|
// InternalRDL.g:5186:1: ( '->' )
|
|
// InternalRDL.g:5187:2: '->'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getHyphenMinusGreaterThanSignKeyword_0_0_1());
|
|
}
|
|
match(input,131,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getHyphenMinusGreaterThanSignKeyword_0_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group_0_0__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group_0_0__2"
|
|
// InternalRDL.g:5196:1: rule__PostPropertyAssignment__Group_0_0__2 : rule__PostPropertyAssignment__Group_0_0__2__Impl ;
|
|
public final void rule__PostPropertyAssignment__Group_0_0__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5200:1: ( rule__PostPropertyAssignment__Group_0_0__2__Impl )
|
|
// InternalRDL.g:5201:2: rule__PostPropertyAssignment__Group_0_0__2__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__Group_0_0__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group_0_0__2"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group_0_0__2__Impl"
|
|
// InternalRDL.g:5207:1: rule__PostPropertyAssignment__Group_0_0__2__Impl : ( ( rule__PostPropertyAssignment__Alternatives_0_0_2 ) ) ;
|
|
public final void rule__PostPropertyAssignment__Group_0_0__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5211:1: ( ( ( rule__PostPropertyAssignment__Alternatives_0_0_2 ) ) )
|
|
// InternalRDL.g:5212:1: ( ( rule__PostPropertyAssignment__Alternatives_0_0_2 ) )
|
|
{
|
|
// InternalRDL.g:5212:1: ( ( rule__PostPropertyAssignment__Alternatives_0_0_2 ) )
|
|
// InternalRDL.g:5213:2: ( rule__PostPropertyAssignment__Alternatives_0_0_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getAlternatives_0_0_2());
|
|
}
|
|
// InternalRDL.g:5214:2: ( rule__PostPropertyAssignment__Alternatives_0_0_2 )
|
|
// InternalRDL.g:5214:3: rule__PostPropertyAssignment__Alternatives_0_0_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__Alternatives_0_0_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getAlternatives_0_0_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group_0_0__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group_1__0"
|
|
// InternalRDL.g:5223:1: rule__PostPropertyAssignment__Group_1__0 : rule__PostPropertyAssignment__Group_1__0__Impl rule__PostPropertyAssignment__Group_1__1 ;
|
|
public final void rule__PostPropertyAssignment__Group_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5227:1: ( rule__PostPropertyAssignment__Group_1__0__Impl rule__PostPropertyAssignment__Group_1__1 )
|
|
// InternalRDL.g:5228:2: rule__PostPropertyAssignment__Group_1__0__Impl rule__PostPropertyAssignment__Group_1__1
|
|
{
|
|
pushFollow(FOLLOW_31);
|
|
rule__PostPropertyAssignment__Group_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__Group_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group_1__0__Impl"
|
|
// InternalRDL.g:5235:1: rule__PostPropertyAssignment__Group_1__0__Impl : ( '=' ) ;
|
|
public final void rule__PostPropertyAssignment__Group_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5239:1: ( ( '=' ) )
|
|
// InternalRDL.g:5240:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:5240:1: ( '=' )
|
|
// InternalRDL.g:5241:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getEqualsSignKeyword_1_0());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getEqualsSignKeyword_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group_1__1"
|
|
// InternalRDL.g:5250:1: rule__PostPropertyAssignment__Group_1__1 : rule__PostPropertyAssignment__Group_1__1__Impl ;
|
|
public final void rule__PostPropertyAssignment__Group_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5254:1: ( rule__PostPropertyAssignment__Group_1__1__Impl )
|
|
// InternalRDL.g:5255:2: rule__PostPropertyAssignment__Group_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__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__PostPropertyAssignment__Group_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__Group_1__1__Impl"
|
|
// InternalRDL.g:5261:1: rule__PostPropertyAssignment__Group_1__1__Impl : ( ( rule__PostPropertyAssignment__RhsAssignment_1_1 ) ) ;
|
|
public final void rule__PostPropertyAssignment__Group_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5265:1: ( ( ( rule__PostPropertyAssignment__RhsAssignment_1_1 ) ) )
|
|
// InternalRDL.g:5266:1: ( ( rule__PostPropertyAssignment__RhsAssignment_1_1 ) )
|
|
{
|
|
// InternalRDL.g:5266:1: ( ( rule__PostPropertyAssignment__RhsAssignment_1_1 ) )
|
|
// InternalRDL.g:5267:2: ( rule__PostPropertyAssignment__RhsAssignment_1_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getRhsAssignment_1_1());
|
|
}
|
|
// InternalRDL.g:5268:2: ( rule__PostPropertyAssignment__RhsAssignment_1_1 )
|
|
// InternalRDL.g:5268:3: rule__PostPropertyAssignment__RhsAssignment_1_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PostPropertyAssignment__RhsAssignment_1_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getRhsAssignment_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__Group_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__Group__0"
|
|
// InternalRDL.g:5277:1: rule__InstancePropertyRef__Group__0 : rule__InstancePropertyRef__Group__0__Impl rule__InstancePropertyRef__Group__1 ;
|
|
public final void rule__InstancePropertyRef__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5281:1: ( rule__InstancePropertyRef__Group__0__Impl rule__InstancePropertyRef__Group__1 )
|
|
// InternalRDL.g:5282:2: rule__InstancePropertyRef__Group__0__Impl rule__InstancePropertyRef__Group__1
|
|
{
|
|
pushFollow(FOLLOW_32);
|
|
rule__InstancePropertyRef__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstancePropertyRef__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstancePropertyRef__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__Group__0__Impl"
|
|
// InternalRDL.g:5289:1: rule__InstancePropertyRef__Group__0__Impl : ( ( rule__InstancePropertyRef__InstanceAssignment_0 ) ) ;
|
|
public final void rule__InstancePropertyRef__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5293:1: ( ( ( rule__InstancePropertyRef__InstanceAssignment_0 ) ) )
|
|
// InternalRDL.g:5294:1: ( ( rule__InstancePropertyRef__InstanceAssignment_0 ) )
|
|
{
|
|
// InternalRDL.g:5294:1: ( ( rule__InstancePropertyRef__InstanceAssignment_0 ) )
|
|
// InternalRDL.g:5295:2: ( rule__InstancePropertyRef__InstanceAssignment_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefAccess().getInstanceAssignment_0());
|
|
}
|
|
// InternalRDL.g:5296:2: ( rule__InstancePropertyRef__InstanceAssignment_0 )
|
|
// InternalRDL.g:5296:3: rule__InstancePropertyRef__InstanceAssignment_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstancePropertyRef__InstanceAssignment_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefAccess().getInstanceAssignment_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstancePropertyRef__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__Group__1"
|
|
// InternalRDL.g:5304:1: rule__InstancePropertyRef__Group__1 : rule__InstancePropertyRef__Group__1__Impl ;
|
|
public final void rule__InstancePropertyRef__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5308:1: ( rule__InstancePropertyRef__Group__1__Impl )
|
|
// InternalRDL.g:5309:2: rule__InstancePropertyRef__Group__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstancePropertyRef__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstancePropertyRef__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__Group__1__Impl"
|
|
// InternalRDL.g:5315:1: rule__InstancePropertyRef__Group__1__Impl : ( ( rule__InstancePropertyRef__Group_1__0 )? ) ;
|
|
public final void rule__InstancePropertyRef__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5319:1: ( ( ( rule__InstancePropertyRef__Group_1__0 )? ) )
|
|
// InternalRDL.g:5320:1: ( ( rule__InstancePropertyRef__Group_1__0 )? )
|
|
{
|
|
// InternalRDL.g:5320:1: ( ( rule__InstancePropertyRef__Group_1__0 )? )
|
|
// InternalRDL.g:5321:2: ( rule__InstancePropertyRef__Group_1__0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefAccess().getGroup_1());
|
|
}
|
|
// InternalRDL.g:5322:2: ( rule__InstancePropertyRef__Group_1__0 )?
|
|
int alt43=2;
|
|
int LA43_0 = input.LA(1);
|
|
|
|
if ( (LA43_0==131) ) {
|
|
alt43=1;
|
|
}
|
|
switch (alt43) {
|
|
case 1 :
|
|
// InternalRDL.g:5322:3: rule__InstancePropertyRef__Group_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstancePropertyRef__Group_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefAccess().getGroup_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstancePropertyRef__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__Group_1__0"
|
|
// InternalRDL.g:5331:1: rule__InstancePropertyRef__Group_1__0 : rule__InstancePropertyRef__Group_1__0__Impl rule__InstancePropertyRef__Group_1__1 ;
|
|
public final void rule__InstancePropertyRef__Group_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5335:1: ( rule__InstancePropertyRef__Group_1__0__Impl rule__InstancePropertyRef__Group_1__1 )
|
|
// InternalRDL.g:5336:2: rule__InstancePropertyRef__Group_1__0__Impl rule__InstancePropertyRef__Group_1__1
|
|
{
|
|
pushFollow(FOLLOW_33);
|
|
rule__InstancePropertyRef__Group_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstancePropertyRef__Group_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstancePropertyRef__Group_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__Group_1__0__Impl"
|
|
// InternalRDL.g:5343:1: rule__InstancePropertyRef__Group_1__0__Impl : ( '->' ) ;
|
|
public final void rule__InstancePropertyRef__Group_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5347:1: ( ( '->' ) )
|
|
// InternalRDL.g:5348:1: ( '->' )
|
|
{
|
|
// InternalRDL.g:5348:1: ( '->' )
|
|
// InternalRDL.g:5349:2: '->'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefAccess().getHyphenMinusGreaterThanSignKeyword_1_0());
|
|
}
|
|
match(input,131,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefAccess().getHyphenMinusGreaterThanSignKeyword_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstancePropertyRef__Group_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__Group_1__1"
|
|
// InternalRDL.g:5358:1: rule__InstancePropertyRef__Group_1__1 : rule__InstancePropertyRef__Group_1__1__Impl ;
|
|
public final void rule__InstancePropertyRef__Group_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5362:1: ( rule__InstancePropertyRef__Group_1__1__Impl )
|
|
// InternalRDL.g:5363:2: rule__InstancePropertyRef__Group_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstancePropertyRef__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__InstancePropertyRef__Group_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__Group_1__1__Impl"
|
|
// InternalRDL.g:5369:1: rule__InstancePropertyRef__Group_1__1__Impl : ( ( rule__InstancePropertyRef__Alternatives_1_1 ) ) ;
|
|
public final void rule__InstancePropertyRef__Group_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5373:1: ( ( ( rule__InstancePropertyRef__Alternatives_1_1 ) ) )
|
|
// InternalRDL.g:5374:1: ( ( rule__InstancePropertyRef__Alternatives_1_1 ) )
|
|
{
|
|
// InternalRDL.g:5374:1: ( ( rule__InstancePropertyRef__Alternatives_1_1 ) )
|
|
// InternalRDL.g:5375:2: ( rule__InstancePropertyRef__Alternatives_1_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefAccess().getAlternatives_1_1());
|
|
}
|
|
// InternalRDL.g:5376:2: ( rule__InstancePropertyRef__Alternatives_1_1 )
|
|
// InternalRDL.g:5376:3: rule__InstancePropertyRef__Alternatives_1_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstancePropertyRef__Alternatives_1_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefAccess().getAlternatives_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstancePropertyRef__Group_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__InstanceRef__Group__0"
|
|
// InternalRDL.g:5385:1: rule__InstanceRef__Group__0 : rule__InstanceRef__Group__0__Impl rule__InstanceRef__Group__1 ;
|
|
public final void rule__InstanceRef__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5389:1: ( rule__InstanceRef__Group__0__Impl rule__InstanceRef__Group__1 )
|
|
// InternalRDL.g:5390:2: rule__InstanceRef__Group__0__Impl rule__InstanceRef__Group__1
|
|
{
|
|
pushFollow(FOLLOW_34);
|
|
rule__InstanceRef__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstanceRef__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstanceRef__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__InstanceRef__Group__0__Impl"
|
|
// InternalRDL.g:5397:1: rule__InstanceRef__Group__0__Impl : ( ( rule__InstanceRef__InstanceAssignment_0 ) ) ;
|
|
public final void rule__InstanceRef__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5401:1: ( ( ( rule__InstanceRef__InstanceAssignment_0 ) ) )
|
|
// InternalRDL.g:5402:1: ( ( rule__InstanceRef__InstanceAssignment_0 ) )
|
|
{
|
|
// InternalRDL.g:5402:1: ( ( rule__InstanceRef__InstanceAssignment_0 ) )
|
|
// InternalRDL.g:5403:2: ( rule__InstanceRef__InstanceAssignment_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstanceRefAccess().getInstanceAssignment_0());
|
|
}
|
|
// InternalRDL.g:5404:2: ( rule__InstanceRef__InstanceAssignment_0 )
|
|
// InternalRDL.g:5404:3: rule__InstanceRef__InstanceAssignment_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstanceRef__InstanceAssignment_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstanceRefAccess().getInstanceAssignment_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstanceRef__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__InstanceRef__Group__1"
|
|
// InternalRDL.g:5412:1: rule__InstanceRef__Group__1 : rule__InstanceRef__Group__1__Impl ;
|
|
public final void rule__InstanceRef__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5416:1: ( rule__InstanceRef__Group__1__Impl )
|
|
// InternalRDL.g:5417:2: rule__InstanceRef__Group__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstanceRef__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstanceRef__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__InstanceRef__Group__1__Impl"
|
|
// InternalRDL.g:5423:1: rule__InstanceRef__Group__1__Impl : ( ( rule__InstanceRef__Group_1__0 )? ) ;
|
|
public final void rule__InstanceRef__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5427:1: ( ( ( rule__InstanceRef__Group_1__0 )? ) )
|
|
// InternalRDL.g:5428:1: ( ( rule__InstanceRef__Group_1__0 )? )
|
|
{
|
|
// InternalRDL.g:5428:1: ( ( rule__InstanceRef__Group_1__0 )? )
|
|
// InternalRDL.g:5429:2: ( rule__InstanceRef__Group_1__0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstanceRefAccess().getGroup_1());
|
|
}
|
|
// InternalRDL.g:5430:2: ( rule__InstanceRef__Group_1__0 )?
|
|
int alt44=2;
|
|
int LA44_0 = input.LA(1);
|
|
|
|
if ( (LA44_0==132) ) {
|
|
alt44=1;
|
|
}
|
|
switch (alt44) {
|
|
case 1 :
|
|
// InternalRDL.g:5430:3: rule__InstanceRef__Group_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstanceRef__Group_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstanceRefAccess().getGroup_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstanceRef__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__InstanceRef__Group_1__0"
|
|
// InternalRDL.g:5439:1: rule__InstanceRef__Group_1__0 : rule__InstanceRef__Group_1__0__Impl rule__InstanceRef__Group_1__1 ;
|
|
public final void rule__InstanceRef__Group_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5443:1: ( rule__InstanceRef__Group_1__0__Impl rule__InstanceRef__Group_1__1 )
|
|
// InternalRDL.g:5444:2: rule__InstanceRef__Group_1__0__Impl rule__InstanceRef__Group_1__1
|
|
{
|
|
pushFollow(FOLLOW_6);
|
|
rule__InstanceRef__Group_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstanceRef__Group_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstanceRef__Group_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__InstanceRef__Group_1__0__Impl"
|
|
// InternalRDL.g:5451:1: rule__InstanceRef__Group_1__0__Impl : ( '.' ) ;
|
|
public final void rule__InstanceRef__Group_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5455:1: ( ( '.' ) )
|
|
// InternalRDL.g:5456:1: ( '.' )
|
|
{
|
|
// InternalRDL.g:5456:1: ( '.' )
|
|
// InternalRDL.g:5457:2: '.'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstanceRefAccess().getFullStopKeyword_1_0());
|
|
}
|
|
match(input,132,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstanceRefAccess().getFullStopKeyword_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstanceRef__Group_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__InstanceRef__Group_1__1"
|
|
// InternalRDL.g:5466:1: rule__InstanceRef__Group_1__1 : rule__InstanceRef__Group_1__1__Impl ;
|
|
public final void rule__InstanceRef__Group_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5470:1: ( rule__InstanceRef__Group_1__1__Impl )
|
|
// InternalRDL.g:5471:2: rule__InstanceRef__Group_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstanceRef__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__InstanceRef__Group_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__InstanceRef__Group_1__1__Impl"
|
|
// InternalRDL.g:5477:1: rule__InstanceRef__Group_1__1__Impl : ( ( rule__InstanceRef__TailAssignment_1_1 ) ) ;
|
|
public final void rule__InstanceRef__Group_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5481:1: ( ( ( rule__InstanceRef__TailAssignment_1_1 ) ) )
|
|
// InternalRDL.g:5482:1: ( ( rule__InstanceRef__TailAssignment_1_1 ) )
|
|
{
|
|
// InternalRDL.g:5482:1: ( ( rule__InstanceRef__TailAssignment_1_1 ) )
|
|
// InternalRDL.g:5483:2: ( rule__InstanceRef__TailAssignment_1_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstanceRefAccess().getTailAssignment_1_1());
|
|
}
|
|
// InternalRDL.g:5484:2: ( rule__InstanceRef__TailAssignment_1_1 )
|
|
// InternalRDL.g:5484:3: rule__InstanceRef__TailAssignment_1_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__InstanceRef__TailAssignment_1_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstanceRefAccess().getTailAssignment_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstanceRef__Group_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__HierInstanceRef__Group__0"
|
|
// InternalRDL.g:5493:1: rule__HierInstanceRef__Group__0 : rule__HierInstanceRef__Group__0__Impl rule__HierInstanceRef__Group__1 ;
|
|
public final void rule__HierInstanceRef__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5497:1: ( rule__HierInstanceRef__Group__0__Impl rule__HierInstanceRef__Group__1 )
|
|
// InternalRDL.g:5498:2: rule__HierInstanceRef__Group__0__Impl rule__HierInstanceRef__Group__1
|
|
{
|
|
pushFollow(FOLLOW_34);
|
|
rule__HierInstanceRef__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__HierInstanceRef__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__HierInstanceRef__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__HierInstanceRef__Group__0__Impl"
|
|
// InternalRDL.g:5505:1: rule__HierInstanceRef__Group__0__Impl : ( ( rule__HierInstanceRef__InstanceAssignment_0 ) ) ;
|
|
public final void rule__HierInstanceRef__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5509:1: ( ( ( rule__HierInstanceRef__InstanceAssignment_0 ) ) )
|
|
// InternalRDL.g:5510:1: ( ( rule__HierInstanceRef__InstanceAssignment_0 ) )
|
|
{
|
|
// InternalRDL.g:5510:1: ( ( rule__HierInstanceRef__InstanceAssignment_0 ) )
|
|
// InternalRDL.g:5511:2: ( rule__HierInstanceRef__InstanceAssignment_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getHierInstanceRefAccess().getInstanceAssignment_0());
|
|
}
|
|
// InternalRDL.g:5512:2: ( rule__HierInstanceRef__InstanceAssignment_0 )
|
|
// InternalRDL.g:5512:3: rule__HierInstanceRef__InstanceAssignment_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__HierInstanceRef__InstanceAssignment_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getHierInstanceRefAccess().getInstanceAssignment_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__HierInstanceRef__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__HierInstanceRef__Group__1"
|
|
// InternalRDL.g:5520:1: rule__HierInstanceRef__Group__1 : rule__HierInstanceRef__Group__1__Impl ;
|
|
public final void rule__HierInstanceRef__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5524:1: ( rule__HierInstanceRef__Group__1__Impl )
|
|
// InternalRDL.g:5525:2: rule__HierInstanceRef__Group__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__HierInstanceRef__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__HierInstanceRef__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__HierInstanceRef__Group__1__Impl"
|
|
// InternalRDL.g:5531:1: rule__HierInstanceRef__Group__1__Impl : ( ( rule__HierInstanceRef__Group_1__0 )? ) ;
|
|
public final void rule__HierInstanceRef__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5535:1: ( ( ( rule__HierInstanceRef__Group_1__0 )? ) )
|
|
// InternalRDL.g:5536:1: ( ( rule__HierInstanceRef__Group_1__0 )? )
|
|
{
|
|
// InternalRDL.g:5536:1: ( ( rule__HierInstanceRef__Group_1__0 )? )
|
|
// InternalRDL.g:5537:2: ( rule__HierInstanceRef__Group_1__0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getHierInstanceRefAccess().getGroup_1());
|
|
}
|
|
// InternalRDL.g:5538:2: ( rule__HierInstanceRef__Group_1__0 )?
|
|
int alt45=2;
|
|
int LA45_0 = input.LA(1);
|
|
|
|
if ( (LA45_0==132) ) {
|
|
alt45=1;
|
|
}
|
|
switch (alt45) {
|
|
case 1 :
|
|
// InternalRDL.g:5538:3: rule__HierInstanceRef__Group_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__HierInstanceRef__Group_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getHierInstanceRefAccess().getGroup_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__HierInstanceRef__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__HierInstanceRef__Group_1__0"
|
|
// InternalRDL.g:5547:1: rule__HierInstanceRef__Group_1__0 : rule__HierInstanceRef__Group_1__0__Impl rule__HierInstanceRef__Group_1__1 ;
|
|
public final void rule__HierInstanceRef__Group_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5551:1: ( rule__HierInstanceRef__Group_1__0__Impl rule__HierInstanceRef__Group_1__1 )
|
|
// InternalRDL.g:5552:2: rule__HierInstanceRef__Group_1__0__Impl rule__HierInstanceRef__Group_1__1
|
|
{
|
|
pushFollow(FOLLOW_6);
|
|
rule__HierInstanceRef__Group_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__HierInstanceRef__Group_1__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__HierInstanceRef__Group_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__HierInstanceRef__Group_1__0__Impl"
|
|
// InternalRDL.g:5559:1: rule__HierInstanceRef__Group_1__0__Impl : ( '.' ) ;
|
|
public final void rule__HierInstanceRef__Group_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5563:1: ( ( '.' ) )
|
|
// InternalRDL.g:5564:1: ( '.' )
|
|
{
|
|
// InternalRDL.g:5564:1: ( '.' )
|
|
// InternalRDL.g:5565:2: '.'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getHierInstanceRefAccess().getFullStopKeyword_1_0());
|
|
}
|
|
match(input,132,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getHierInstanceRefAccess().getFullStopKeyword_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__HierInstanceRef__Group_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__HierInstanceRef__Group_1__1"
|
|
// InternalRDL.g:5574:1: rule__HierInstanceRef__Group_1__1 : rule__HierInstanceRef__Group_1__1__Impl ;
|
|
public final void rule__HierInstanceRef__Group_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5578:1: ( rule__HierInstanceRef__Group_1__1__Impl )
|
|
// InternalRDL.g:5579:2: rule__HierInstanceRef__Group_1__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__HierInstanceRef__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__HierInstanceRef__Group_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__HierInstanceRef__Group_1__1__Impl"
|
|
// InternalRDL.g:5585:1: rule__HierInstanceRef__Group_1__1__Impl : ( ( rule__HierInstanceRef__TailAssignment_1_1 ) ) ;
|
|
public final void rule__HierInstanceRef__Group_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5589:1: ( ( ( rule__HierInstanceRef__TailAssignment_1_1 ) ) )
|
|
// InternalRDL.g:5590:1: ( ( rule__HierInstanceRef__TailAssignment_1_1 ) )
|
|
{
|
|
// InternalRDL.g:5590:1: ( ( rule__HierInstanceRef__TailAssignment_1_1 ) )
|
|
// InternalRDL.g:5591:2: ( rule__HierInstanceRef__TailAssignment_1_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getHierInstanceRefAccess().getTailAssignment_1_1());
|
|
}
|
|
// InternalRDL.g:5592:2: ( rule__HierInstanceRef__TailAssignment_1_1 )
|
|
// InternalRDL.g:5592:3: rule__HierInstanceRef__TailAssignment_1_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__HierInstanceRef__TailAssignment_1_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getHierInstanceRefAccess().getTailAssignment_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__HierInstanceRef__Group_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__Group_2__0"
|
|
// InternalRDL.g:5601:1: rule__PropertyAssignmentRhs__Group_2__0 : rule__PropertyAssignmentRhs__Group_2__0__Impl rule__PropertyAssignmentRhs__Group_2__1 ;
|
|
public final void rule__PropertyAssignmentRhs__Group_2__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5605:1: ( rule__PropertyAssignmentRhs__Group_2__0__Impl rule__PropertyAssignmentRhs__Group_2__1 )
|
|
// InternalRDL.g:5606:2: rule__PropertyAssignmentRhs__Group_2__0__Impl rule__PropertyAssignmentRhs__Group_2__1
|
|
{
|
|
pushFollow(FOLLOW_35);
|
|
rule__PropertyAssignmentRhs__Group_2__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyAssignmentRhs__Group_2__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__Group_2__0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__Group_2__0__Impl"
|
|
// InternalRDL.g:5613:1: rule__PropertyAssignmentRhs__Group_2__0__Impl : ( ( rule__PropertyAssignmentRhs__EnumRefAssignment_2_0 ) ) ;
|
|
public final void rule__PropertyAssignmentRhs__Group_2__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5617:1: ( ( ( rule__PropertyAssignmentRhs__EnumRefAssignment_2_0 ) ) )
|
|
// InternalRDL.g:5618:1: ( ( rule__PropertyAssignmentRhs__EnumRefAssignment_2_0 ) )
|
|
{
|
|
// InternalRDL.g:5618:1: ( ( rule__PropertyAssignmentRhs__EnumRefAssignment_2_0 ) )
|
|
// InternalRDL.g:5619:2: ( rule__PropertyAssignmentRhs__EnumRefAssignment_2_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getEnumRefAssignment_2_0());
|
|
}
|
|
// InternalRDL.g:5620:2: ( rule__PropertyAssignmentRhs__EnumRefAssignment_2_0 )
|
|
// InternalRDL.g:5620:3: rule__PropertyAssignmentRhs__EnumRefAssignment_2_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyAssignmentRhs__EnumRefAssignment_2_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getEnumRefAssignment_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__Group_2__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__Group_2__1"
|
|
// InternalRDL.g:5628:1: rule__PropertyAssignmentRhs__Group_2__1 : rule__PropertyAssignmentRhs__Group_2__1__Impl rule__PropertyAssignmentRhs__Group_2__2 ;
|
|
public final void rule__PropertyAssignmentRhs__Group_2__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5632:1: ( rule__PropertyAssignmentRhs__Group_2__1__Impl rule__PropertyAssignmentRhs__Group_2__2 )
|
|
// InternalRDL.g:5633:2: rule__PropertyAssignmentRhs__Group_2__1__Impl rule__PropertyAssignmentRhs__Group_2__2
|
|
{
|
|
pushFollow(FOLLOW_7);
|
|
rule__PropertyAssignmentRhs__Group_2__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyAssignmentRhs__Group_2__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__Group_2__1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__Group_2__1__Impl"
|
|
// InternalRDL.g:5640:1: rule__PropertyAssignmentRhs__Group_2__1__Impl : ( 'enum' ) ;
|
|
public final void rule__PropertyAssignmentRhs__Group_2__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5644:1: ( ( 'enum' ) )
|
|
// InternalRDL.g:5645:1: ( 'enum' )
|
|
{
|
|
// InternalRDL.g:5645:1: ( 'enum' )
|
|
// InternalRDL.g:5646:2: 'enum'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getEnumKeyword_2_1());
|
|
}
|
|
match(input,133,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getEnumKeyword_2_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__Group_2__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__Group_2__2"
|
|
// InternalRDL.g:5655:1: rule__PropertyAssignmentRhs__Group_2__2 : rule__PropertyAssignmentRhs__Group_2__2__Impl ;
|
|
public final void rule__PropertyAssignmentRhs__Group_2__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5659:1: ( rule__PropertyAssignmentRhs__Group_2__2__Impl )
|
|
// InternalRDL.g:5660:2: rule__PropertyAssignmentRhs__Group_2__2__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyAssignmentRhs__Group_2__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__Group_2__2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__Group_2__2__Impl"
|
|
// InternalRDL.g:5666:1: rule__PropertyAssignmentRhs__Group_2__2__Impl : ( ( rule__PropertyAssignmentRhs__EnumsAssignment_2_2 ) ) ;
|
|
public final void rule__PropertyAssignmentRhs__Group_2__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5670:1: ( ( ( rule__PropertyAssignmentRhs__EnumsAssignment_2_2 ) ) )
|
|
// InternalRDL.g:5671:1: ( ( rule__PropertyAssignmentRhs__EnumsAssignment_2_2 ) )
|
|
{
|
|
// InternalRDL.g:5671:1: ( ( rule__PropertyAssignmentRhs__EnumsAssignment_2_2 ) )
|
|
// InternalRDL.g:5672:2: ( rule__PropertyAssignmentRhs__EnumsAssignment_2_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getEnumsAssignment_2_2());
|
|
}
|
|
// InternalRDL.g:5673:2: ( rule__PropertyAssignmentRhs__EnumsAssignment_2_2 )
|
|
// InternalRDL.g:5673:3: rule__PropertyAssignmentRhs__EnumsAssignment_2_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__PropertyAssignmentRhs__EnumsAssignment_2_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getEnumsAssignment_2_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__Group_2__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group__0"
|
|
// InternalRDL.g:5682:1: rule__Concat__Group__0 : rule__Concat__Group__0__Impl rule__Concat__Group__1 ;
|
|
public final void rule__Concat__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5686:1: ( rule__Concat__Group__0__Impl rule__Concat__Group__1 )
|
|
// InternalRDL.g:5687:2: rule__Concat__Group__0__Impl rule__Concat__Group__1
|
|
{
|
|
pushFollow(FOLLOW_36);
|
|
rule__Concat__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Concat__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group__0__Impl"
|
|
// InternalRDL.g:5694:1: rule__Concat__Group__0__Impl : ( '{' ) ;
|
|
public final void rule__Concat__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5698:1: ( ( '{' ) )
|
|
// InternalRDL.g:5699:1: ( '{' )
|
|
{
|
|
// InternalRDL.g:5699:1: ( '{' )
|
|
// InternalRDL.g:5700:2: '{'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatAccess().getLeftCurlyBracketKeyword_0());
|
|
}
|
|
match(input,116,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatAccess().getLeftCurlyBracketKeyword_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group__1"
|
|
// InternalRDL.g:5709:1: rule__Concat__Group__1 : rule__Concat__Group__1__Impl rule__Concat__Group__2 ;
|
|
public final void rule__Concat__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5713:1: ( rule__Concat__Group__1__Impl rule__Concat__Group__2 )
|
|
// InternalRDL.g:5714:2: rule__Concat__Group__1__Impl rule__Concat__Group__2
|
|
{
|
|
pushFollow(FOLLOW_37);
|
|
rule__Concat__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Concat__Group__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group__1__Impl"
|
|
// InternalRDL.g:5721:1: rule__Concat__Group__1__Impl : ( ( rule__Concat__ElementsAssignment_1 ) ) ;
|
|
public final void rule__Concat__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5725:1: ( ( ( rule__Concat__ElementsAssignment_1 ) ) )
|
|
// InternalRDL.g:5726:1: ( ( rule__Concat__ElementsAssignment_1 ) )
|
|
{
|
|
// InternalRDL.g:5726:1: ( ( rule__Concat__ElementsAssignment_1 ) )
|
|
// InternalRDL.g:5727:2: ( rule__Concat__ElementsAssignment_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatAccess().getElementsAssignment_1());
|
|
}
|
|
// InternalRDL.g:5728:2: ( rule__Concat__ElementsAssignment_1 )
|
|
// InternalRDL.g:5728:3: rule__Concat__ElementsAssignment_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Concat__ElementsAssignment_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatAccess().getElementsAssignment_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group__2"
|
|
// InternalRDL.g:5736:1: rule__Concat__Group__2 : rule__Concat__Group__2__Impl rule__Concat__Group__3 ;
|
|
public final void rule__Concat__Group__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5740:1: ( rule__Concat__Group__2__Impl rule__Concat__Group__3 )
|
|
// InternalRDL.g:5741:2: rule__Concat__Group__2__Impl rule__Concat__Group__3
|
|
{
|
|
pushFollow(FOLLOW_37);
|
|
rule__Concat__Group__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Concat__Group__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__Group__2"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group__2__Impl"
|
|
// InternalRDL.g:5748:1: rule__Concat__Group__2__Impl : ( ( rule__Concat__Group_2__0 )* ) ;
|
|
public final void rule__Concat__Group__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5752:1: ( ( ( rule__Concat__Group_2__0 )* ) )
|
|
// InternalRDL.g:5753:1: ( ( rule__Concat__Group_2__0 )* )
|
|
{
|
|
// InternalRDL.g:5753:1: ( ( rule__Concat__Group_2__0 )* )
|
|
// InternalRDL.g:5754:2: ( rule__Concat__Group_2__0 )*
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatAccess().getGroup_2());
|
|
}
|
|
// InternalRDL.g:5755:2: ( rule__Concat__Group_2__0 )*
|
|
loop46:
|
|
do {
|
|
int alt46=2;
|
|
int LA46_0 = input.LA(1);
|
|
|
|
if ( (LA46_0==124) ) {
|
|
alt46=1;
|
|
}
|
|
|
|
|
|
switch (alt46) {
|
|
case 1 :
|
|
// InternalRDL.g:5755:3: rule__Concat__Group_2__0
|
|
{
|
|
pushFollow(FOLLOW_23);
|
|
rule__Concat__Group_2__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop46;
|
|
}
|
|
} while (true);
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatAccess().getGroup_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__Group__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group__3"
|
|
// InternalRDL.g:5763:1: rule__Concat__Group__3 : rule__Concat__Group__3__Impl ;
|
|
public final void rule__Concat__Group__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5767:1: ( rule__Concat__Group__3__Impl )
|
|
// InternalRDL.g:5768:2: rule__Concat__Group__3__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Concat__Group__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__Group__3"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group__3__Impl"
|
|
// InternalRDL.g:5774:1: rule__Concat__Group__3__Impl : ( '}' ) ;
|
|
public final void rule__Concat__Group__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5778:1: ( ( '}' ) )
|
|
// InternalRDL.g:5779:1: ( '}' )
|
|
{
|
|
// InternalRDL.g:5779:1: ( '}' )
|
|
// InternalRDL.g:5780:2: '}'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatAccess().getRightCurlyBracketKeyword_3());
|
|
}
|
|
match(input,117,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatAccess().getRightCurlyBracketKeyword_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__Group__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group_2__0"
|
|
// InternalRDL.g:5790:1: rule__Concat__Group_2__0 : rule__Concat__Group_2__0__Impl rule__Concat__Group_2__1 ;
|
|
public final void rule__Concat__Group_2__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5794:1: ( rule__Concat__Group_2__0__Impl rule__Concat__Group_2__1 )
|
|
// InternalRDL.g:5795:2: rule__Concat__Group_2__0__Impl rule__Concat__Group_2__1
|
|
{
|
|
pushFollow(FOLLOW_36);
|
|
rule__Concat__Group_2__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__Concat__Group_2__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__Group_2__0"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group_2__0__Impl"
|
|
// InternalRDL.g:5802:1: rule__Concat__Group_2__0__Impl : ( ',' ) ;
|
|
public final void rule__Concat__Group_2__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5806:1: ( ( ',' ) )
|
|
// InternalRDL.g:5807:1: ( ',' )
|
|
{
|
|
// InternalRDL.g:5807:1: ( ',' )
|
|
// InternalRDL.g:5808:2: ','
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatAccess().getCommaKeyword_2_0());
|
|
}
|
|
match(input,124,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatAccess().getCommaKeyword_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__Group_2__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group_2__1"
|
|
// InternalRDL.g:5817:1: rule__Concat__Group_2__1 : rule__Concat__Group_2__1__Impl ;
|
|
public final void rule__Concat__Group_2__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5821:1: ( rule__Concat__Group_2__1__Impl )
|
|
// InternalRDL.g:5822:2: rule__Concat__Group_2__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Concat__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__Concat__Group_2__1"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__Group_2__1__Impl"
|
|
// InternalRDL.g:5828:1: rule__Concat__Group_2__1__Impl : ( ( rule__Concat__ElementsAssignment_2_1 ) ) ;
|
|
public final void rule__Concat__Group_2__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5832:1: ( ( ( rule__Concat__ElementsAssignment_2_1 ) ) )
|
|
// InternalRDL.g:5833:1: ( ( rule__Concat__ElementsAssignment_2_1 ) )
|
|
{
|
|
// InternalRDL.g:5833:1: ( ( rule__Concat__ElementsAssignment_2_1 ) )
|
|
// InternalRDL.g:5834:2: ( rule__Concat__ElementsAssignment_2_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatAccess().getElementsAssignment_2_1());
|
|
}
|
|
// InternalRDL.g:5835:2: ( rule__Concat__ElementsAssignment_2_1 )
|
|
// InternalRDL.g:5835:3: rule__Concat__ElementsAssignment_2_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Concat__ElementsAssignment_2_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatAccess().getElementsAssignment_2_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__Group_2__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumDefinition__Group__0"
|
|
// InternalRDL.g:5844:1: rule__EnumDefinition__Group__0 : rule__EnumDefinition__Group__0__Impl rule__EnumDefinition__Group__1 ;
|
|
public final void rule__EnumDefinition__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5848:1: ( rule__EnumDefinition__Group__0__Impl rule__EnumDefinition__Group__1 )
|
|
// InternalRDL.g:5849:2: rule__EnumDefinition__Group__0__Impl rule__EnumDefinition__Group__1
|
|
{
|
|
pushFollow(FOLLOW_6);
|
|
rule__EnumDefinition__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumDefinition__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumDefinition__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumDefinition__Group__0__Impl"
|
|
// InternalRDL.g:5856:1: rule__EnumDefinition__Group__0__Impl : ( 'enum' ) ;
|
|
public final void rule__EnumDefinition__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5860:1: ( ( 'enum' ) )
|
|
// InternalRDL.g:5861:1: ( 'enum' )
|
|
{
|
|
// InternalRDL.g:5861:1: ( 'enum' )
|
|
// InternalRDL.g:5862:2: 'enum'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumDefinitionAccess().getEnumKeyword_0());
|
|
}
|
|
match(input,133,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumDefinitionAccess().getEnumKeyword_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumDefinition__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumDefinition__Group__1"
|
|
// InternalRDL.g:5871:1: rule__EnumDefinition__Group__1 : rule__EnumDefinition__Group__1__Impl rule__EnumDefinition__Group__2 ;
|
|
public final void rule__EnumDefinition__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5875:1: ( rule__EnumDefinition__Group__1__Impl rule__EnumDefinition__Group__2 )
|
|
// InternalRDL.g:5876:2: rule__EnumDefinition__Group__1__Impl rule__EnumDefinition__Group__2
|
|
{
|
|
pushFollow(FOLLOW_7);
|
|
rule__EnumDefinition__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumDefinition__Group__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumDefinition__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__EnumDefinition__Group__1__Impl"
|
|
// InternalRDL.g:5883:1: rule__EnumDefinition__Group__1__Impl : ( ( rule__EnumDefinition__NameAssignment_1 ) ) ;
|
|
public final void rule__EnumDefinition__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5887:1: ( ( ( rule__EnumDefinition__NameAssignment_1 ) ) )
|
|
// InternalRDL.g:5888:1: ( ( rule__EnumDefinition__NameAssignment_1 ) )
|
|
{
|
|
// InternalRDL.g:5888:1: ( ( rule__EnumDefinition__NameAssignment_1 ) )
|
|
// InternalRDL.g:5889:2: ( rule__EnumDefinition__NameAssignment_1 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumDefinitionAccess().getNameAssignment_1());
|
|
}
|
|
// InternalRDL.g:5890:2: ( rule__EnumDefinition__NameAssignment_1 )
|
|
// InternalRDL.g:5890:3: rule__EnumDefinition__NameAssignment_1
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumDefinition__NameAssignment_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumDefinitionAccess().getNameAssignment_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumDefinition__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumDefinition__Group__2"
|
|
// InternalRDL.g:5898:1: rule__EnumDefinition__Group__2 : rule__EnumDefinition__Group__2__Impl ;
|
|
public final void rule__EnumDefinition__Group__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5902:1: ( rule__EnumDefinition__Group__2__Impl )
|
|
// InternalRDL.g:5903:2: rule__EnumDefinition__Group__2__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumDefinition__Group__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumDefinition__Group__2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumDefinition__Group__2__Impl"
|
|
// InternalRDL.g:5909:1: rule__EnumDefinition__Group__2__Impl : ( ( rule__EnumDefinition__BodyAssignment_2 ) ) ;
|
|
public final void rule__EnumDefinition__Group__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5913:1: ( ( ( rule__EnumDefinition__BodyAssignment_2 ) ) )
|
|
// InternalRDL.g:5914:1: ( ( rule__EnumDefinition__BodyAssignment_2 ) )
|
|
{
|
|
// InternalRDL.g:5914:1: ( ( rule__EnumDefinition__BodyAssignment_2 ) )
|
|
// InternalRDL.g:5915:2: ( rule__EnumDefinition__BodyAssignment_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumDefinitionAccess().getBodyAssignment_2());
|
|
}
|
|
// InternalRDL.g:5916:2: ( rule__EnumDefinition__BodyAssignment_2 )
|
|
// InternalRDL.g:5916:3: rule__EnumDefinition__BodyAssignment_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumDefinition__BodyAssignment_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumDefinitionAccess().getBodyAssignment_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumDefinition__Group__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumBody__Group__0"
|
|
// InternalRDL.g:5925:1: rule__EnumBody__Group__0 : rule__EnumBody__Group__0__Impl rule__EnumBody__Group__1 ;
|
|
public final void rule__EnumBody__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5929:1: ( rule__EnumBody__Group__0__Impl rule__EnumBody__Group__1 )
|
|
// InternalRDL.g:5930:2: rule__EnumBody__Group__0__Impl rule__EnumBody__Group__1
|
|
{
|
|
pushFollow(FOLLOW_38);
|
|
rule__EnumBody__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumBody__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumBody__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumBody__Group__0__Impl"
|
|
// InternalRDL.g:5937:1: rule__EnumBody__Group__0__Impl : ( '{' ) ;
|
|
public final void rule__EnumBody__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5941:1: ( ( '{' ) )
|
|
// InternalRDL.g:5942:1: ( '{' )
|
|
{
|
|
// InternalRDL.g:5942:1: ( '{' )
|
|
// InternalRDL.g:5943:2: '{'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumBodyAccess().getLeftCurlyBracketKeyword_0());
|
|
}
|
|
match(input,116,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumBodyAccess().getLeftCurlyBracketKeyword_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumBody__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumBody__Group__1"
|
|
// InternalRDL.g:5952:1: rule__EnumBody__Group__1 : rule__EnumBody__Group__1__Impl rule__EnumBody__Group__2 ;
|
|
public final void rule__EnumBody__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5956:1: ( rule__EnumBody__Group__1__Impl rule__EnumBody__Group__2 )
|
|
// InternalRDL.g:5957:2: rule__EnumBody__Group__1__Impl rule__EnumBody__Group__2
|
|
{
|
|
pushFollow(FOLLOW_38);
|
|
rule__EnumBody__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumBody__Group__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumBody__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__EnumBody__Group__1__Impl"
|
|
// InternalRDL.g:5964:1: rule__EnumBody__Group__1__Impl : ( () ) ;
|
|
public final void rule__EnumBody__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5968:1: ( ( () ) )
|
|
// InternalRDL.g:5969:1: ( () )
|
|
{
|
|
// InternalRDL.g:5969:1: ( () )
|
|
// InternalRDL.g:5970:2: ()
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumBodyAccess().getEnumBodyAction_1());
|
|
}
|
|
// InternalRDL.g:5971:2: ()
|
|
// InternalRDL.g:5971:3:
|
|
{
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumBodyAccess().getEnumBodyAction_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumBody__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumBody__Group__2"
|
|
// InternalRDL.g:5979:1: rule__EnumBody__Group__2 : rule__EnumBody__Group__2__Impl rule__EnumBody__Group__3 ;
|
|
public final void rule__EnumBody__Group__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5983:1: ( rule__EnumBody__Group__2__Impl rule__EnumBody__Group__3 )
|
|
// InternalRDL.g:5984:2: rule__EnumBody__Group__2__Impl rule__EnumBody__Group__3
|
|
{
|
|
pushFollow(FOLLOW_38);
|
|
rule__EnumBody__Group__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumBody__Group__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumBody__Group__2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumBody__Group__2__Impl"
|
|
// InternalRDL.g:5991:1: rule__EnumBody__Group__2__Impl : ( ( rule__EnumBody__EntriesAssignment_2 )* ) ;
|
|
public final void rule__EnumBody__Group__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:5995:1: ( ( ( rule__EnumBody__EntriesAssignment_2 )* ) )
|
|
// InternalRDL.g:5996:1: ( ( rule__EnumBody__EntriesAssignment_2 )* )
|
|
{
|
|
// InternalRDL.g:5996:1: ( ( rule__EnumBody__EntriesAssignment_2 )* )
|
|
// InternalRDL.g:5997:2: ( rule__EnumBody__EntriesAssignment_2 )*
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumBodyAccess().getEntriesAssignment_2());
|
|
}
|
|
// InternalRDL.g:5998:2: ( rule__EnumBody__EntriesAssignment_2 )*
|
|
loop47:
|
|
do {
|
|
int alt47=2;
|
|
int LA47_0 = input.LA(1);
|
|
|
|
if ( (LA47_0==RULE_ID) ) {
|
|
alt47=1;
|
|
}
|
|
|
|
|
|
switch (alt47) {
|
|
case 1 :
|
|
// InternalRDL.g:5998:3: rule__EnumBody__EntriesAssignment_2
|
|
{
|
|
pushFollow(FOLLOW_39);
|
|
rule__EnumBody__EntriesAssignment_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop47;
|
|
}
|
|
} while (true);
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumBodyAccess().getEntriesAssignment_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumBody__Group__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumBody__Group__3"
|
|
// InternalRDL.g:6006:1: rule__EnumBody__Group__3 : rule__EnumBody__Group__3__Impl ;
|
|
public final void rule__EnumBody__Group__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6010:1: ( rule__EnumBody__Group__3__Impl )
|
|
// InternalRDL.g:6011:2: rule__EnumBody__Group__3__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumBody__Group__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumBody__Group__3"
|
|
|
|
|
|
// $ANTLR start "rule__EnumBody__Group__3__Impl"
|
|
// InternalRDL.g:6017:1: rule__EnumBody__Group__3__Impl : ( '}' ) ;
|
|
public final void rule__EnumBody__Group__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6021:1: ( ( '}' ) )
|
|
// InternalRDL.g:6022:1: ( '}' )
|
|
{
|
|
// InternalRDL.g:6022:1: ( '}' )
|
|
// InternalRDL.g:6023:2: '}'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumBodyAccess().getRightCurlyBracketKeyword_3());
|
|
}
|
|
match(input,117,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumBodyAccess().getRightCurlyBracketKeyword_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumBody__Group__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group__0"
|
|
// InternalRDL.g:6033:1: rule__EnumEntry__Group__0 : rule__EnumEntry__Group__0__Impl rule__EnumEntry__Group__1 ;
|
|
public final void rule__EnumEntry__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6037:1: ( rule__EnumEntry__Group__0__Impl rule__EnumEntry__Group__1 )
|
|
// InternalRDL.g:6038:2: rule__EnumEntry__Group__0__Impl rule__EnumEntry__Group__1
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__EnumEntry__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group__0__Impl"
|
|
// InternalRDL.g:6045:1: rule__EnumEntry__Group__0__Impl : ( ( rule__EnumEntry__NameAssignment_0 ) ) ;
|
|
public final void rule__EnumEntry__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6049:1: ( ( ( rule__EnumEntry__NameAssignment_0 ) ) )
|
|
// InternalRDL.g:6050:1: ( ( rule__EnumEntry__NameAssignment_0 ) )
|
|
{
|
|
// InternalRDL.g:6050:1: ( ( rule__EnumEntry__NameAssignment_0 ) )
|
|
// InternalRDL.g:6051:2: ( rule__EnumEntry__NameAssignment_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getNameAssignment_0());
|
|
}
|
|
// InternalRDL.g:6052:2: ( rule__EnumEntry__NameAssignment_0 )
|
|
// InternalRDL.g:6052:3: rule__EnumEntry__NameAssignment_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__NameAssignment_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getNameAssignment_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group__1"
|
|
// InternalRDL.g:6060:1: rule__EnumEntry__Group__1 : rule__EnumEntry__Group__1__Impl rule__EnumEntry__Group__2 ;
|
|
public final void rule__EnumEntry__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6064:1: ( rule__EnumEntry__Group__1__Impl rule__EnumEntry__Group__2 )
|
|
// InternalRDL.g:6065:2: rule__EnumEntry__Group__1__Impl rule__EnumEntry__Group__2
|
|
{
|
|
pushFollow(FOLLOW_27);
|
|
rule__EnumEntry__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__Group__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group__1__Impl"
|
|
// InternalRDL.g:6072:1: rule__EnumEntry__Group__1__Impl : ( '=' ) ;
|
|
public final void rule__EnumEntry__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6076:1: ( ( '=' ) )
|
|
// InternalRDL.g:6077:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:6077:1: ( '=' )
|
|
// InternalRDL.g:6078:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getEqualsSignKeyword_1());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getEqualsSignKeyword_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group__2"
|
|
// InternalRDL.g:6087:1: rule__EnumEntry__Group__2 : rule__EnumEntry__Group__2__Impl rule__EnumEntry__Group__3 ;
|
|
public final void rule__EnumEntry__Group__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6091:1: ( rule__EnumEntry__Group__2__Impl rule__EnumEntry__Group__3 )
|
|
// InternalRDL.g:6092:2: rule__EnumEntry__Group__2__Impl rule__EnumEntry__Group__3
|
|
{
|
|
pushFollow(FOLLOW_40);
|
|
rule__EnumEntry__Group__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__Group__3();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group__2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group__2__Impl"
|
|
// InternalRDL.g:6099:1: rule__EnumEntry__Group__2__Impl : ( ( rule__EnumEntry__IndexAssignment_2 ) ) ;
|
|
public final void rule__EnumEntry__Group__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6103:1: ( ( ( rule__EnumEntry__IndexAssignment_2 ) ) )
|
|
// InternalRDL.g:6104:1: ( ( rule__EnumEntry__IndexAssignment_2 ) )
|
|
{
|
|
// InternalRDL.g:6104:1: ( ( rule__EnumEntry__IndexAssignment_2 ) )
|
|
// InternalRDL.g:6105:2: ( rule__EnumEntry__IndexAssignment_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getIndexAssignment_2());
|
|
}
|
|
// InternalRDL.g:6106:2: ( rule__EnumEntry__IndexAssignment_2 )
|
|
// InternalRDL.g:6106:3: rule__EnumEntry__IndexAssignment_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__IndexAssignment_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getIndexAssignment_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group__3"
|
|
// InternalRDL.g:6114:1: rule__EnumEntry__Group__3 : rule__EnumEntry__Group__3__Impl rule__EnumEntry__Group__4 ;
|
|
public final void rule__EnumEntry__Group__3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6118:1: ( rule__EnumEntry__Group__3__Impl rule__EnumEntry__Group__4 )
|
|
// InternalRDL.g:6119:2: rule__EnumEntry__Group__3__Impl rule__EnumEntry__Group__4
|
|
{
|
|
pushFollow(FOLLOW_40);
|
|
rule__EnumEntry__Group__3__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__Group__4();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group__3"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group__3__Impl"
|
|
// InternalRDL.g:6126:1: rule__EnumEntry__Group__3__Impl : ( ( rule__EnumEntry__Group_3__0 )? ) ;
|
|
public final void rule__EnumEntry__Group__3__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6130:1: ( ( ( rule__EnumEntry__Group_3__0 )? ) )
|
|
// InternalRDL.g:6131:1: ( ( rule__EnumEntry__Group_3__0 )? )
|
|
{
|
|
// InternalRDL.g:6131:1: ( ( rule__EnumEntry__Group_3__0 )? )
|
|
// InternalRDL.g:6132:2: ( rule__EnumEntry__Group_3__0 )?
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getGroup_3());
|
|
}
|
|
// InternalRDL.g:6133:2: ( rule__EnumEntry__Group_3__0 )?
|
|
int alt48=2;
|
|
int LA48_0 = input.LA(1);
|
|
|
|
if ( (LA48_0==116) ) {
|
|
alt48=1;
|
|
}
|
|
switch (alt48) {
|
|
case 1 :
|
|
// InternalRDL.g:6133:3: rule__EnumEntry__Group_3__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__Group_3__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getGroup_3());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group__3__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group__4"
|
|
// InternalRDL.g:6141:1: rule__EnumEntry__Group__4 : rule__EnumEntry__Group__4__Impl ;
|
|
public final void rule__EnumEntry__Group__4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6145:1: ( rule__EnumEntry__Group__4__Impl )
|
|
// InternalRDL.g:6146:2: rule__EnumEntry__Group__4__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__Group__4__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group__4"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group__4__Impl"
|
|
// InternalRDL.g:6152:1: rule__EnumEntry__Group__4__Impl : ( ';' ) ;
|
|
public final void rule__EnumEntry__Group__4__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6156:1: ( ( ';' ) )
|
|
// InternalRDL.g:6157:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:6157:1: ( ';' )
|
|
// InternalRDL.g:6158:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getSemicolonKeyword_4());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getSemicolonKeyword_4());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group__4__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group_3__0"
|
|
// InternalRDL.g:6168:1: rule__EnumEntry__Group_3__0 : rule__EnumEntry__Group_3__0__Impl rule__EnumEntry__Group_3__1 ;
|
|
public final void rule__EnumEntry__Group_3__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6172:1: ( rule__EnumEntry__Group_3__0__Impl rule__EnumEntry__Group_3__1 )
|
|
// InternalRDL.g:6173:2: rule__EnumEntry__Group_3__0__Impl rule__EnumEntry__Group_3__1
|
|
{
|
|
pushFollow(FOLLOW_41);
|
|
rule__EnumEntry__Group_3__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__Group_3__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group_3__0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group_3__0__Impl"
|
|
// InternalRDL.g:6180:1: rule__EnumEntry__Group_3__0__Impl : ( '{' ) ;
|
|
public final void rule__EnumEntry__Group_3__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6184:1: ( ( '{' ) )
|
|
// InternalRDL.g:6185:1: ( '{' )
|
|
{
|
|
// InternalRDL.g:6185:1: ( '{' )
|
|
// InternalRDL.g:6186:2: '{'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getLeftCurlyBracketKeyword_3_0());
|
|
}
|
|
match(input,116,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getLeftCurlyBracketKeyword_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group_3__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group_3__1"
|
|
// InternalRDL.g:6195:1: rule__EnumEntry__Group_3__1 : rule__EnumEntry__Group_3__1__Impl rule__EnumEntry__Group_3__2 ;
|
|
public final void rule__EnumEntry__Group_3__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6199:1: ( rule__EnumEntry__Group_3__1__Impl rule__EnumEntry__Group_3__2 )
|
|
// InternalRDL.g:6200:2: rule__EnumEntry__Group_3__1__Impl rule__EnumEntry__Group_3__2
|
|
{
|
|
pushFollow(FOLLOW_41);
|
|
rule__EnumEntry__Group_3__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__Group_3__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group_3__1"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group_3__1__Impl"
|
|
// InternalRDL.g:6207:1: rule__EnumEntry__Group_3__1__Impl : ( ( rule__EnumEntry__PropertiesAssignment_3_1 )* ) ;
|
|
public final void rule__EnumEntry__Group_3__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6211:1: ( ( ( rule__EnumEntry__PropertiesAssignment_3_1 )* ) )
|
|
// InternalRDL.g:6212:1: ( ( rule__EnumEntry__PropertiesAssignment_3_1 )* )
|
|
{
|
|
// InternalRDL.g:6212:1: ( ( rule__EnumEntry__PropertiesAssignment_3_1 )* )
|
|
// InternalRDL.g:6213:2: ( rule__EnumEntry__PropertiesAssignment_3_1 )*
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getPropertiesAssignment_3_1());
|
|
}
|
|
// InternalRDL.g:6214:2: ( rule__EnumEntry__PropertiesAssignment_3_1 )*
|
|
loop49:
|
|
do {
|
|
int alt49=2;
|
|
int LA49_0 = input.LA(1);
|
|
|
|
if ( ((LA49_0>=22 && LA49_0<=23)) ) {
|
|
alt49=1;
|
|
}
|
|
|
|
|
|
switch (alt49) {
|
|
case 1 :
|
|
// InternalRDL.g:6214:3: rule__EnumEntry__PropertiesAssignment_3_1
|
|
{
|
|
pushFollow(FOLLOW_42);
|
|
rule__EnumEntry__PropertiesAssignment_3_1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop49;
|
|
}
|
|
} while (true);
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getPropertiesAssignment_3_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group_3__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group_3__2"
|
|
// InternalRDL.g:6222:1: rule__EnumEntry__Group_3__2 : rule__EnumEntry__Group_3__2__Impl ;
|
|
public final void rule__EnumEntry__Group_3__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6226:1: ( rule__EnumEntry__Group_3__2__Impl )
|
|
// InternalRDL.g:6227:2: rule__EnumEntry__Group_3__2__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumEntry__Group_3__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group_3__2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__Group_3__2__Impl"
|
|
// InternalRDL.g:6233:1: rule__EnumEntry__Group_3__2__Impl : ( '}' ) ;
|
|
public final void rule__EnumEntry__Group_3__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6237:1: ( ( '}' ) )
|
|
// InternalRDL.g:6238:1: ( '}' )
|
|
{
|
|
// InternalRDL.g:6238:1: ( '}' )
|
|
// InternalRDL.g:6239:2: '}'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getRightCurlyBracketKeyword_3_2());
|
|
}
|
|
match(input,117,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getRightCurlyBracketKeyword_3_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__Group_3__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group__0"
|
|
// InternalRDL.g:6249:1: rule__EnumProperty__Group__0 : rule__EnumProperty__Group__0__Impl rule__EnumProperty__Group__1 ;
|
|
public final void rule__EnumProperty__Group__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6253:1: ( rule__EnumProperty__Group__0__Impl rule__EnumProperty__Group__1 )
|
|
// InternalRDL.g:6254:2: rule__EnumProperty__Group__0__Impl rule__EnumProperty__Group__1
|
|
{
|
|
pushFollow(FOLLOW_4);
|
|
rule__EnumProperty__Group__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__Group__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group__0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group__0__Impl"
|
|
// InternalRDL.g:6261:1: rule__EnumProperty__Group__0__Impl : ( ( rule__EnumProperty__Alternatives_0 ) ) ;
|
|
public final void rule__EnumProperty__Group__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6265:1: ( ( ( rule__EnumProperty__Alternatives_0 ) ) )
|
|
// InternalRDL.g:6266:1: ( ( rule__EnumProperty__Alternatives_0 ) )
|
|
{
|
|
// InternalRDL.g:6266:1: ( ( rule__EnumProperty__Alternatives_0 ) )
|
|
// InternalRDL.g:6267:2: ( rule__EnumProperty__Alternatives_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getAlternatives_0());
|
|
}
|
|
// InternalRDL.g:6268:2: ( rule__EnumProperty__Alternatives_0 )
|
|
// InternalRDL.g:6268:3: rule__EnumProperty__Alternatives_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__Alternatives_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getAlternatives_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group__1"
|
|
// InternalRDL.g:6276:1: rule__EnumProperty__Group__1 : rule__EnumProperty__Group__1__Impl ;
|
|
public final void rule__EnumProperty__Group__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6280:1: ( rule__EnumProperty__Group__1__Impl )
|
|
// InternalRDL.g:6281:2: rule__EnumProperty__Group__1__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__Group__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group__1"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group__1__Impl"
|
|
// InternalRDL.g:6287:1: rule__EnumProperty__Group__1__Impl : ( ';' ) ;
|
|
public final void rule__EnumProperty__Group__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6291:1: ( ( ';' ) )
|
|
// InternalRDL.g:6292:1: ( ';' )
|
|
{
|
|
// InternalRDL.g:6292:1: ( ';' )
|
|
// InternalRDL.g:6293:2: ';'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getSemicolonKeyword_1());
|
|
}
|
|
match(input,113,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getSemicolonKeyword_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_0__0"
|
|
// InternalRDL.g:6303:1: rule__EnumProperty__Group_0_0__0 : rule__EnumProperty__Group_0_0__0__Impl rule__EnumProperty__Group_0_0__1 ;
|
|
public final void rule__EnumProperty__Group_0_0__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6307:1: ( rule__EnumProperty__Group_0_0__0__Impl rule__EnumProperty__Group_0_0__1 )
|
|
// InternalRDL.g:6308:2: rule__EnumProperty__Group_0_0__0__Impl rule__EnumProperty__Group_0_0__1
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__EnumProperty__Group_0_0__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__Group_0_0__1();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group_0_0__0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_0__0__Impl"
|
|
// InternalRDL.g:6315:1: rule__EnumProperty__Group_0_0__0__Impl : ( ( rule__EnumProperty__NameAssignment_0_0_0 ) ) ;
|
|
public final void rule__EnumProperty__Group_0_0__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6319:1: ( ( ( rule__EnumProperty__NameAssignment_0_0_0 ) ) )
|
|
// InternalRDL.g:6320:1: ( ( rule__EnumProperty__NameAssignment_0_0_0 ) )
|
|
{
|
|
// InternalRDL.g:6320:1: ( ( rule__EnumProperty__NameAssignment_0_0_0 ) )
|
|
// InternalRDL.g:6321:2: ( rule__EnumProperty__NameAssignment_0_0_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getNameAssignment_0_0_0());
|
|
}
|
|
// InternalRDL.g:6322:2: ( rule__EnumProperty__NameAssignment_0_0_0 )
|
|
// InternalRDL.g:6322:3: rule__EnumProperty__NameAssignment_0_0_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__NameAssignment_0_0_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getNameAssignment_0_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group_0_0__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_0__1"
|
|
// InternalRDL.g:6330:1: rule__EnumProperty__Group_0_0__1 : rule__EnumProperty__Group_0_0__1__Impl rule__EnumProperty__Group_0_0__2 ;
|
|
public final void rule__EnumProperty__Group_0_0__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6334:1: ( rule__EnumProperty__Group_0_0__1__Impl rule__EnumProperty__Group_0_0__2 )
|
|
// InternalRDL.g:6335:2: rule__EnumProperty__Group_0_0__1__Impl rule__EnumProperty__Group_0_0__2
|
|
{
|
|
pushFollow(FOLLOW_5);
|
|
rule__EnumProperty__Group_0_0__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__Group_0_0__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group_0_0__1"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_0__1__Impl"
|
|
// InternalRDL.g:6342:1: rule__EnumProperty__Group_0_0__1__Impl : ( '=' ) ;
|
|
public final void rule__EnumProperty__Group_0_0__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6346:1: ( ( '=' ) )
|
|
// InternalRDL.g:6347:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:6347:1: ( '=' )
|
|
// InternalRDL.g:6348:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getEqualsSignKeyword_0_0_1());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getEqualsSignKeyword_0_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group_0_0__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_0__2"
|
|
// InternalRDL.g:6357:1: rule__EnumProperty__Group_0_0__2 : rule__EnumProperty__Group_0_0__2__Impl ;
|
|
public final void rule__EnumProperty__Group_0_0__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6361:1: ( rule__EnumProperty__Group_0_0__2__Impl )
|
|
// InternalRDL.g:6362:2: rule__EnumProperty__Group_0_0__2__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__Group_0_0__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group_0_0__2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_0__2__Impl"
|
|
// InternalRDL.g:6368:1: rule__EnumProperty__Group_0_0__2__Impl : ( ( rule__EnumProperty__ValueAssignment_0_0_2 ) ) ;
|
|
public final void rule__EnumProperty__Group_0_0__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6372:1: ( ( ( rule__EnumProperty__ValueAssignment_0_0_2 ) ) )
|
|
// InternalRDL.g:6373:1: ( ( rule__EnumProperty__ValueAssignment_0_0_2 ) )
|
|
{
|
|
// InternalRDL.g:6373:1: ( ( rule__EnumProperty__ValueAssignment_0_0_2 ) )
|
|
// InternalRDL.g:6374:2: ( rule__EnumProperty__ValueAssignment_0_0_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getValueAssignment_0_0_2());
|
|
}
|
|
// InternalRDL.g:6375:2: ( rule__EnumProperty__ValueAssignment_0_0_2 )
|
|
// InternalRDL.g:6375:3: rule__EnumProperty__ValueAssignment_0_0_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__ValueAssignment_0_0_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getValueAssignment_0_0_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group_0_0__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_1__0"
|
|
// InternalRDL.g:6384:1: rule__EnumProperty__Group_0_1__0 : rule__EnumProperty__Group_0_1__0__Impl rule__EnumProperty__Group_0_1__1 ;
|
|
public final void rule__EnumProperty__Group_0_1__0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6388:1: ( rule__EnumProperty__Group_0_1__0__Impl rule__EnumProperty__Group_0_1__1 )
|
|
// InternalRDL.g:6389:2: rule__EnumProperty__Group_0_1__0__Impl rule__EnumProperty__Group_0_1__1
|
|
{
|
|
pushFollow(FOLLOW_10);
|
|
rule__EnumProperty__Group_0_1__0__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__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__EnumProperty__Group_0_1__0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_1__0__Impl"
|
|
// InternalRDL.g:6396:1: rule__EnumProperty__Group_0_1__0__Impl : ( ( rule__EnumProperty__NameAssignment_0_1_0 ) ) ;
|
|
public final void rule__EnumProperty__Group_0_1__0__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6400:1: ( ( ( rule__EnumProperty__NameAssignment_0_1_0 ) ) )
|
|
// InternalRDL.g:6401:1: ( ( rule__EnumProperty__NameAssignment_0_1_0 ) )
|
|
{
|
|
// InternalRDL.g:6401:1: ( ( rule__EnumProperty__NameAssignment_0_1_0 ) )
|
|
// InternalRDL.g:6402:2: ( rule__EnumProperty__NameAssignment_0_1_0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getNameAssignment_0_1_0());
|
|
}
|
|
// InternalRDL.g:6403:2: ( rule__EnumProperty__NameAssignment_0_1_0 )
|
|
// InternalRDL.g:6403:3: rule__EnumProperty__NameAssignment_0_1_0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__NameAssignment_0_1_0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getNameAssignment_0_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group_0_1__0__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_1__1"
|
|
// InternalRDL.g:6411:1: rule__EnumProperty__Group_0_1__1 : rule__EnumProperty__Group_0_1__1__Impl rule__EnumProperty__Group_0_1__2 ;
|
|
public final void rule__EnumProperty__Group_0_1__1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6415:1: ( rule__EnumProperty__Group_0_1__1__Impl rule__EnumProperty__Group_0_1__2 )
|
|
// InternalRDL.g:6416:2: rule__EnumProperty__Group_0_1__1__Impl rule__EnumProperty__Group_0_1__2
|
|
{
|
|
pushFollow(FOLLOW_5);
|
|
rule__EnumProperty__Group_0_1__1__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__Group_0_1__2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group_0_1__1"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_1__1__Impl"
|
|
// InternalRDL.g:6423:1: rule__EnumProperty__Group_0_1__1__Impl : ( '=' ) ;
|
|
public final void rule__EnumProperty__Group_0_1__1__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6427:1: ( ( '=' ) )
|
|
// InternalRDL.g:6428:1: ( '=' )
|
|
{
|
|
// InternalRDL.g:6428:1: ( '=' )
|
|
// InternalRDL.g:6429:2: '='
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getEqualsSignKeyword_0_1_1());
|
|
}
|
|
match(input,119,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getEqualsSignKeyword_0_1_1());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group_0_1__1__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_1__2"
|
|
// InternalRDL.g:6438:1: rule__EnumProperty__Group_0_1__2 : rule__EnumProperty__Group_0_1__2__Impl ;
|
|
public final void rule__EnumProperty__Group_0_1__2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6442:1: ( rule__EnumProperty__Group_0_1__2__Impl )
|
|
// InternalRDL.g:6443:2: rule__EnumProperty__Group_0_1__2__Impl
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__Group_0_1__2__Impl();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group_0_1__2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__Group_0_1__2__Impl"
|
|
// InternalRDL.g:6449:1: rule__EnumProperty__Group_0_1__2__Impl : ( ( rule__EnumProperty__ValueAssignment_0_1_2 ) ) ;
|
|
public final void rule__EnumProperty__Group_0_1__2__Impl() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6453:1: ( ( ( rule__EnumProperty__ValueAssignment_0_1_2 ) ) )
|
|
// InternalRDL.g:6454:1: ( ( rule__EnumProperty__ValueAssignment_0_1_2 ) )
|
|
{
|
|
// InternalRDL.g:6454:1: ( ( rule__EnumProperty__ValueAssignment_0_1_2 ) )
|
|
// InternalRDL.g:6455:2: ( rule__EnumProperty__ValueAssignment_0_1_2 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getValueAssignment_0_1_2());
|
|
}
|
|
// InternalRDL.g:6456:2: ( rule__EnumProperty__ValueAssignment_0_1_2 )
|
|
// InternalRDL.g:6456:3: rule__EnumProperty__ValueAssignment_0_1_2
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__EnumProperty__ValueAssignment_0_1_2();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getValueAssignment_0_1_2());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__Group_0_1__2__Impl"
|
|
|
|
|
|
// $ANTLR start "rule__Root__IncludesAssignment_0"
|
|
// InternalRDL.g:6465:1: rule__Root__IncludesAssignment_0 : ( ruleInclude ) ;
|
|
public final void rule__Root__IncludesAssignment_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6469:1: ( ( ruleInclude ) )
|
|
// InternalRDL.g:6470:2: ( ruleInclude )
|
|
{
|
|
// InternalRDL.g:6470:2: ( ruleInclude )
|
|
// InternalRDL.g:6471:3: ruleInclude
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getIncludesIncludeParserRuleCall_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleInclude();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getIncludesIncludeParserRuleCall_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__IncludesAssignment_0"
|
|
|
|
|
|
// $ANTLR start "rule__Root__ComponentDefinitionsAssignment_1_0"
|
|
// InternalRDL.g:6480:1: rule__Root__ComponentDefinitionsAssignment_1_0 : ( ruleComponentDefinition ) ;
|
|
public final void rule__Root__ComponentDefinitionsAssignment_1_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6484:1: ( ( ruleComponentDefinition ) )
|
|
// InternalRDL.g:6485:2: ( ruleComponentDefinition )
|
|
{
|
|
// InternalRDL.g:6485:2: ( ruleComponentDefinition )
|
|
// InternalRDL.g:6486:3: ruleComponentDefinition
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getComponentDefinitionsComponentDefinitionParserRuleCall_1_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleComponentDefinition();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getComponentDefinitionsComponentDefinitionParserRuleCall_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__ComponentDefinitionsAssignment_1_0"
|
|
|
|
|
|
// $ANTLR start "rule__Root__EnumDefinitionsAssignment_2_0"
|
|
// InternalRDL.g:6495:1: rule__Root__EnumDefinitionsAssignment_2_0 : ( ruleEnumDefinition ) ;
|
|
public final void rule__Root__EnumDefinitionsAssignment_2_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6499:1: ( ( ruleEnumDefinition ) )
|
|
// InternalRDL.g:6500:2: ( ruleEnumDefinition )
|
|
{
|
|
// InternalRDL.g:6500:2: ( ruleEnumDefinition )
|
|
// InternalRDL.g:6501:3: ruleEnumDefinition
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getEnumDefinitionsEnumDefinitionParserRuleCall_2_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleEnumDefinition();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getEnumDefinitionsEnumDefinitionParserRuleCall_2_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__EnumDefinitionsAssignment_2_0"
|
|
|
|
|
|
// $ANTLR start "rule__Root__InstantiationsAssignment_3_0"
|
|
// InternalRDL.g:6510:1: rule__Root__InstantiationsAssignment_3_0 : ( ruleInstantiation ) ;
|
|
public final void rule__Root__InstantiationsAssignment_3_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6514:1: ( ( ruleInstantiation ) )
|
|
// InternalRDL.g:6515:2: ( ruleInstantiation )
|
|
{
|
|
// InternalRDL.g:6515:2: ( ruleInstantiation )
|
|
// InternalRDL.g:6516:3: ruleInstantiation
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getInstantiationsInstantiationParserRuleCall_3_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleInstantiation();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getInstantiationsInstantiationParserRuleCall_3_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__InstantiationsAssignment_3_0"
|
|
|
|
|
|
// $ANTLR start "rule__Root__PropertyAssignmentsAssignment_4_0"
|
|
// InternalRDL.g:6525:1: rule__Root__PropertyAssignmentsAssignment_4_0 : ( rulePropertyAssignment ) ;
|
|
public final void rule__Root__PropertyAssignmentsAssignment_4_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6529:1: ( ( rulePropertyAssignment ) )
|
|
// InternalRDL.g:6530:2: ( rulePropertyAssignment )
|
|
{
|
|
// InternalRDL.g:6530:2: ( rulePropertyAssignment )
|
|
// InternalRDL.g:6531:3: rulePropertyAssignment
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getPropertyAssignmentsPropertyAssignmentParserRuleCall_4_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyAssignment();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getPropertyAssignmentsPropertyAssignmentParserRuleCall_4_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__PropertyAssignmentsAssignment_4_0"
|
|
|
|
|
|
// $ANTLR start "rule__Root__PropertyDefinitionsAssignment_5_0"
|
|
// InternalRDL.g:6540:1: rule__Root__PropertyDefinitionsAssignment_5_0 : ( rulePropertyDefinition ) ;
|
|
public final void rule__Root__PropertyDefinitionsAssignment_5_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6544:1: ( ( rulePropertyDefinition ) )
|
|
// InternalRDL.g:6545:2: ( rulePropertyDefinition )
|
|
{
|
|
// InternalRDL.g:6545:2: ( rulePropertyDefinition )
|
|
// InternalRDL.g:6546:3: rulePropertyDefinition
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getPropertyDefinitionsPropertyDefinitionParserRuleCall_5_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyDefinition();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRootAccess().getPropertyDefinitionsPropertyDefinitionParserRuleCall_5_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Root__PropertyDefinitionsAssignment_5_0"
|
|
|
|
|
|
// $ANTLR start "rule__Include__ImportURIAssignment_1"
|
|
// InternalRDL.g:6555:1: rule__Include__ImportURIAssignment_1 : ( RULE_STR ) ;
|
|
public final void rule__Include__ImportURIAssignment_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6559:1: ( ( RULE_STR ) )
|
|
// InternalRDL.g:6560:2: ( RULE_STR )
|
|
{
|
|
// InternalRDL.g:6560:2: ( RULE_STR )
|
|
// InternalRDL.g:6561:3: RULE_STR
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getIncludeAccess().getImportURISTRTerminalRuleCall_1_0());
|
|
}
|
|
match(input,RULE_STR,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getIncludeAccess().getImportURISTRTerminalRuleCall_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Include__ImportURIAssignment_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__NameAssignment_1"
|
|
// InternalRDL.g:6570:1: rule__PropertyDefinition__NameAssignment_1 : ( RULE_ID ) ;
|
|
public final void rule__PropertyDefinition__NameAssignment_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6574:1: ( ( RULE_ID ) )
|
|
// InternalRDL.g:6575:2: ( RULE_ID )
|
|
{
|
|
// InternalRDL.g:6575:2: ( RULE_ID )
|
|
// InternalRDL.g:6576:3: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getNameIDTerminalRuleCall_1_0());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getNameIDTerminalRuleCall_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__NameAssignment_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__TypeAssignment_3_0_2"
|
|
// InternalRDL.g:6585:1: rule__PropertyDefinition__TypeAssignment_3_0_2 : ( rulePropertyTypeName ) ;
|
|
public final void rule__PropertyDefinition__TypeAssignment_3_0_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6589:1: ( ( rulePropertyTypeName ) )
|
|
// InternalRDL.g:6590:2: ( rulePropertyTypeName )
|
|
{
|
|
// InternalRDL.g:6590:2: ( rulePropertyTypeName )
|
|
// InternalRDL.g:6591:3: rulePropertyTypeName
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypePropertyTypeNameEnumRuleCall_3_0_2_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyTypeName();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypePropertyTypeNameEnumRuleCall_3_0_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__TypeAssignment_3_0_2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__UsageAssignment_3_0_4_0_0"
|
|
// InternalRDL.g:6600:1: rule__PropertyDefinition__UsageAssignment_3_0_4_0_0 : ( rulePropertyUsage ) ;
|
|
public final void rule__PropertyDefinition__UsageAssignment_3_0_4_0_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6604:1: ( ( rulePropertyUsage ) )
|
|
// InternalRDL.g:6605:2: ( rulePropertyUsage )
|
|
{
|
|
// InternalRDL.g:6605:2: ( rulePropertyUsage )
|
|
// InternalRDL.g:6606:3: rulePropertyUsage
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getUsagePropertyUsageParserRuleCall_3_0_4_0_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyUsage();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getUsagePropertyUsageParserRuleCall_3_0_4_0_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__UsageAssignment_3_0_4_0_0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1"
|
|
// InternalRDL.g:6615:1: rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1 : ( rulePropertyDefault ) ;
|
|
public final void rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6619:1: ( ( rulePropertyDefault ) )
|
|
// InternalRDL.g:6620:2: ( rulePropertyDefault )
|
|
{
|
|
// InternalRDL.g:6620:2: ( rulePropertyDefault )
|
|
// InternalRDL.g:6621:3: rulePropertyDefault
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getDefaultPropertyDefaultParserRuleCall_3_0_4_0_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyDefault();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getDefaultPropertyDefaultParserRuleCall_3_0_4_0_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__DefaultAssignment_3_0_4_0_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0"
|
|
// InternalRDL.g:6630:1: rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0 : ( rulePropertyDefault ) ;
|
|
public final void rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6634:1: ( ( rulePropertyDefault ) )
|
|
// InternalRDL.g:6635:2: ( rulePropertyDefault )
|
|
{
|
|
// InternalRDL.g:6635:2: ( rulePropertyDefault )
|
|
// InternalRDL.g:6636:3: rulePropertyDefault
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getDefaultPropertyDefaultParserRuleCall_3_0_4_1_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyDefault();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getDefaultPropertyDefaultParserRuleCall_3_0_4_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__DefaultAssignment_3_0_4_1_0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__UsageAssignment_3_0_4_1_1"
|
|
// InternalRDL.g:6645:1: rule__PropertyDefinition__UsageAssignment_3_0_4_1_1 : ( rulePropertyUsage ) ;
|
|
public final void rule__PropertyDefinition__UsageAssignment_3_0_4_1_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6649:1: ( ( rulePropertyUsage ) )
|
|
// InternalRDL.g:6650:2: ( rulePropertyUsage )
|
|
{
|
|
// InternalRDL.g:6650:2: ( rulePropertyUsage )
|
|
// InternalRDL.g:6651:3: rulePropertyUsage
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getUsagePropertyUsageParserRuleCall_3_0_4_1_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyUsage();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getUsagePropertyUsageParserRuleCall_3_0_4_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__UsageAssignment_3_0_4_1_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__UsageAssignment_3_1_0"
|
|
// InternalRDL.g:6660:1: rule__PropertyDefinition__UsageAssignment_3_1_0 : ( rulePropertyUsage ) ;
|
|
public final void rule__PropertyDefinition__UsageAssignment_3_1_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6664:1: ( ( rulePropertyUsage ) )
|
|
// InternalRDL.g:6665:2: ( rulePropertyUsage )
|
|
{
|
|
// InternalRDL.g:6665:2: ( rulePropertyUsage )
|
|
// InternalRDL.g:6666:3: rulePropertyUsage
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getUsagePropertyUsageParserRuleCall_3_1_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyUsage();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getUsagePropertyUsageParserRuleCall_3_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__UsageAssignment_3_1_0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__TypeAssignment_3_1_1_0_2"
|
|
// InternalRDL.g:6675:1: rule__PropertyDefinition__TypeAssignment_3_1_1_0_2 : ( rulePropertyTypeName ) ;
|
|
public final void rule__PropertyDefinition__TypeAssignment_3_1_1_0_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6679:1: ( ( rulePropertyTypeName ) )
|
|
// InternalRDL.g:6680:2: ( rulePropertyTypeName )
|
|
{
|
|
// InternalRDL.g:6680:2: ( rulePropertyTypeName )
|
|
// InternalRDL.g:6681:3: rulePropertyTypeName
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypePropertyTypeNameEnumRuleCall_3_1_1_0_2_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyTypeName();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypePropertyTypeNameEnumRuleCall_3_1_1_0_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__TypeAssignment_3_1_1_0_2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4"
|
|
// InternalRDL.g:6690:1: rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4 : ( rulePropertyDefault ) ;
|
|
public final void rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6694:1: ( ( rulePropertyDefault ) )
|
|
// InternalRDL.g:6695:2: ( rulePropertyDefault )
|
|
{
|
|
// InternalRDL.g:6695:2: ( rulePropertyDefault )
|
|
// InternalRDL.g:6696:3: rulePropertyDefault
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getDefaultPropertyDefaultParserRuleCall_3_1_1_0_4_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyDefault();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getDefaultPropertyDefaultParserRuleCall_3_1_1_0_4_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__DefaultAssignment_3_1_1_0_4"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0"
|
|
// InternalRDL.g:6705:1: rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0 : ( rulePropertyDefault ) ;
|
|
public final void rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6709:1: ( ( rulePropertyDefault ) )
|
|
// InternalRDL.g:6710:2: ( rulePropertyDefault )
|
|
{
|
|
// InternalRDL.g:6710:2: ( rulePropertyDefault )
|
|
// InternalRDL.g:6711:3: rulePropertyDefault
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getDefaultPropertyDefaultParserRuleCall_3_1_1_1_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyDefault();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getDefaultPropertyDefaultParserRuleCall_3_1_1_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__DefaultAssignment_3_1_1_1_0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__TypeAssignment_3_1_1_1_3"
|
|
// InternalRDL.g:6720:1: rule__PropertyDefinition__TypeAssignment_3_1_1_1_3 : ( rulePropertyTypeName ) ;
|
|
public final void rule__PropertyDefinition__TypeAssignment_3_1_1_1_3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6724:1: ( ( rulePropertyTypeName ) )
|
|
// InternalRDL.g:6725:2: ( rulePropertyTypeName )
|
|
{
|
|
// InternalRDL.g:6725:2: ( rulePropertyTypeName )
|
|
// InternalRDL.g:6726:3: rulePropertyTypeName
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypePropertyTypeNameEnumRuleCall_3_1_1_1_3_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyTypeName();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypePropertyTypeNameEnumRuleCall_3_1_1_1_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__TypeAssignment_3_1_1_1_3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__DefaultAssignment_3_2_0"
|
|
// InternalRDL.g:6735:1: rule__PropertyDefinition__DefaultAssignment_3_2_0 : ( rulePropertyDefault ) ;
|
|
public final void rule__PropertyDefinition__DefaultAssignment_3_2_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6739:1: ( ( rulePropertyDefault ) )
|
|
// InternalRDL.g:6740:2: ( rulePropertyDefault )
|
|
{
|
|
// InternalRDL.g:6740:2: ( rulePropertyDefault )
|
|
// InternalRDL.g:6741:3: rulePropertyDefault
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getDefaultPropertyDefaultParserRuleCall_3_2_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyDefault();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getDefaultPropertyDefaultParserRuleCall_3_2_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__DefaultAssignment_3_2_0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__TypeAssignment_3_2_1_0_2"
|
|
// InternalRDL.g:6750:1: rule__PropertyDefinition__TypeAssignment_3_2_1_0_2 : ( rulePropertyTypeName ) ;
|
|
public final void rule__PropertyDefinition__TypeAssignment_3_2_1_0_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6754:1: ( ( rulePropertyTypeName ) )
|
|
// InternalRDL.g:6755:2: ( rulePropertyTypeName )
|
|
{
|
|
// InternalRDL.g:6755:2: ( rulePropertyTypeName )
|
|
// InternalRDL.g:6756:3: rulePropertyTypeName
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypePropertyTypeNameEnumRuleCall_3_2_1_0_2_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyTypeName();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypePropertyTypeNameEnumRuleCall_3_2_1_0_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__TypeAssignment_3_2_1_0_2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__UsageAssignment_3_2_1_0_4"
|
|
// InternalRDL.g:6765:1: rule__PropertyDefinition__UsageAssignment_3_2_1_0_4 : ( rulePropertyUsage ) ;
|
|
public final void rule__PropertyDefinition__UsageAssignment_3_2_1_0_4() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6769:1: ( ( rulePropertyUsage ) )
|
|
// InternalRDL.g:6770:2: ( rulePropertyUsage )
|
|
{
|
|
// InternalRDL.g:6770:2: ( rulePropertyUsage )
|
|
// InternalRDL.g:6771:3: rulePropertyUsage
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getUsagePropertyUsageParserRuleCall_3_2_1_0_4_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyUsage();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getUsagePropertyUsageParserRuleCall_3_2_1_0_4_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__UsageAssignment_3_2_1_0_4"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__UsageAssignment_3_2_1_1_0"
|
|
// InternalRDL.g:6780:1: rule__PropertyDefinition__UsageAssignment_3_2_1_1_0 : ( rulePropertyUsage ) ;
|
|
public final void rule__PropertyDefinition__UsageAssignment_3_2_1_1_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6784:1: ( ( rulePropertyUsage ) )
|
|
// InternalRDL.g:6785:2: ( rulePropertyUsage )
|
|
{
|
|
// InternalRDL.g:6785:2: ( rulePropertyUsage )
|
|
// InternalRDL.g:6786:3: rulePropertyUsage
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getUsagePropertyUsageParserRuleCall_3_2_1_1_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyUsage();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getUsagePropertyUsageParserRuleCall_3_2_1_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__UsageAssignment_3_2_1_1_0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefinition__TypeAssignment_3_2_1_1_3"
|
|
// InternalRDL.g:6795:1: rule__PropertyDefinition__TypeAssignment_3_2_1_1_3 : ( rulePropertyTypeName ) ;
|
|
public final void rule__PropertyDefinition__TypeAssignment_3_2_1_1_3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6799:1: ( ( rulePropertyTypeName ) )
|
|
// InternalRDL.g:6800:2: ( rulePropertyTypeName )
|
|
{
|
|
// InternalRDL.g:6800:2: ( rulePropertyTypeName )
|
|
// InternalRDL.g:6801:3: rulePropertyTypeName
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefinitionAccess().getTypePropertyTypeNameEnumRuleCall_3_2_1_1_3_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyTypeName();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefinitionAccess().getTypePropertyTypeNameEnumRuleCall_3_2_1_1_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefinition__TypeAssignment_3_2_1_1_3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__StringAssignment_2_0"
|
|
// InternalRDL.g:6810:1: rule__PropertyDefault__StringAssignment_2_0 : ( RULE_STR ) ;
|
|
public final void rule__PropertyDefault__StringAssignment_2_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6814:1: ( ( RULE_STR ) )
|
|
// InternalRDL.g:6815:2: ( RULE_STR )
|
|
{
|
|
// InternalRDL.g:6815:2: ( RULE_STR )
|
|
// InternalRDL.g:6816:3: RULE_STR
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getStringSTRTerminalRuleCall_2_0_0());
|
|
}
|
|
match(input,RULE_STR,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getStringSTRTerminalRuleCall_2_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__StringAssignment_2_0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__ValueAssignment_2_1"
|
|
// InternalRDL.g:6825:1: rule__PropertyDefault__ValueAssignment_2_1 : ( RULE_NUM ) ;
|
|
public final void rule__PropertyDefault__ValueAssignment_2_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6829:1: ( ( RULE_NUM ) )
|
|
// InternalRDL.g:6830:2: ( RULE_NUM )
|
|
{
|
|
// InternalRDL.g:6830:2: ( RULE_NUM )
|
|
// InternalRDL.g:6831:3: RULE_NUM
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getValueNUMTerminalRuleCall_2_1_0());
|
|
}
|
|
match(input,RULE_NUM,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getValueNUMTerminalRuleCall_2_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__ValueAssignment_2_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__StringAssignment_2_2"
|
|
// InternalRDL.g:6840:1: rule__PropertyDefault__StringAssignment_2_2 : ( ( 'true' ) ) ;
|
|
public final void rule__PropertyDefault__StringAssignment_2_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6844:1: ( ( ( 'true' ) ) )
|
|
// InternalRDL.g:6845:2: ( ( 'true' ) )
|
|
{
|
|
// InternalRDL.g:6845:2: ( ( 'true' ) )
|
|
// InternalRDL.g:6846:3: ( 'true' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getStringTrueKeyword_2_2_0());
|
|
}
|
|
// InternalRDL.g:6847:3: ( 'true' )
|
|
// InternalRDL.g:6848:4: 'true'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getStringTrueKeyword_2_2_0());
|
|
}
|
|
match(input,98,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getStringTrueKeyword_2_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getStringTrueKeyword_2_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__StringAssignment_2_2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyDefault__StringAssignment_2_3"
|
|
// InternalRDL.g:6859:1: rule__PropertyDefault__StringAssignment_2_3 : ( ( 'false' ) ) ;
|
|
public final void rule__PropertyDefault__StringAssignment_2_3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6863:1: ( ( ( 'false' ) ) )
|
|
// InternalRDL.g:6864:2: ( ( 'false' ) )
|
|
{
|
|
// InternalRDL.g:6864:2: ( ( 'false' ) )
|
|
// InternalRDL.g:6865:3: ( 'false' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getStringFalseKeyword_2_3_0());
|
|
}
|
|
// InternalRDL.g:6866:3: ( 'false' )
|
|
// InternalRDL.g:6867:4: 'false'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyDefaultAccess().getStringFalseKeyword_2_3_0());
|
|
}
|
|
match(input,99,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getStringFalseKeyword_2_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyDefaultAccess().getStringFalseKeyword_2_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyDefault__StringAssignment_2_3"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__ComponentsAssignment_2"
|
|
// InternalRDL.g:6878:1: rule__PropertyUsage__ComponentsAssignment_2 : ( rulePropertyComponent ) ;
|
|
public final void rule__PropertyUsage__ComponentsAssignment_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6882:1: ( ( rulePropertyComponent ) )
|
|
// InternalRDL.g:6883:2: ( rulePropertyComponent )
|
|
{
|
|
// InternalRDL.g:6883:2: ( rulePropertyComponent )
|
|
// InternalRDL.g:6884:3: rulePropertyComponent
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyUsageAccess().getComponentsPropertyComponentEnumRuleCall_2_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyComponent();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyUsageAccess().getComponentsPropertyComponentEnumRuleCall_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__ComponentsAssignment_2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyUsage__ComponentsAssignment_3_1"
|
|
// InternalRDL.g:6893:1: rule__PropertyUsage__ComponentsAssignment_3_1 : ( rulePropertyComponent ) ;
|
|
public final void rule__PropertyUsage__ComponentsAssignment_3_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6897:1: ( ( rulePropertyComponent ) )
|
|
// InternalRDL.g:6898:2: ( rulePropertyComponent )
|
|
{
|
|
// InternalRDL.g:6898:2: ( rulePropertyComponent )
|
|
// InternalRDL.g:6899:3: rulePropertyComponent
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyUsageAccess().getComponentsPropertyComponentEnumRuleCall_3_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyComponent();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyUsageAccess().getComponentsPropertyComponentEnumRuleCall_3_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyUsage__ComponentsAssignment_3_1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__TypeAssignment_0"
|
|
// InternalRDL.g:6908:1: rule__ComponentDefinition__TypeAssignment_0 : ( ruleComponentDefinitionType ) ;
|
|
public final void rule__ComponentDefinition__TypeAssignment_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6912:1: ( ( ruleComponentDefinitionType ) )
|
|
// InternalRDL.g:6913:2: ( ruleComponentDefinitionType )
|
|
{
|
|
// InternalRDL.g:6913:2: ( ruleComponentDefinitionType )
|
|
// InternalRDL.g:6914:3: ruleComponentDefinitionType
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getTypeComponentDefinitionTypeEnumRuleCall_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleComponentDefinitionType();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getTypeComponentDefinitionTypeEnumRuleCall_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__TypeAssignment_0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__NameAssignment_1"
|
|
// InternalRDL.g:6923:1: rule__ComponentDefinition__NameAssignment_1 : ( RULE_ID ) ;
|
|
public final void rule__ComponentDefinition__NameAssignment_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6927:1: ( ( RULE_ID ) )
|
|
// InternalRDL.g:6928:2: ( RULE_ID )
|
|
{
|
|
// InternalRDL.g:6928:2: ( RULE_ID )
|
|
// InternalRDL.g:6929:3: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getNameIDTerminalRuleCall_1_0());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getNameIDTerminalRuleCall_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__NameAssignment_1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0"
|
|
// InternalRDL.g:6938:1: rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0 : ( ruleComponentDefinition ) ;
|
|
public final void rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6942:1: ( ( ruleComponentDefinition ) )
|
|
// InternalRDL.g:6943:2: ( ruleComponentDefinition )
|
|
{
|
|
// InternalRDL.g:6943:2: ( ruleComponentDefinition )
|
|
// InternalRDL.g:6944:3: ruleComponentDefinition
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getComponentDefinitionsComponentDefinitionParserRuleCall_3_0_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleComponentDefinition();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getComponentDefinitionsComponentDefinitionParserRuleCall_3_0_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__ComponentDefinitionsAssignment_3_0_0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__InstantiationsAssignment_3_1_0"
|
|
// InternalRDL.g:6953:1: rule__ComponentDefinition__InstantiationsAssignment_3_1_0 : ( ruleInstantiation ) ;
|
|
public final void rule__ComponentDefinition__InstantiationsAssignment_3_1_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6957:1: ( ( ruleInstantiation ) )
|
|
// InternalRDL.g:6958:2: ( ruleInstantiation )
|
|
{
|
|
// InternalRDL.g:6958:2: ( ruleInstantiation )
|
|
// InternalRDL.g:6959:3: ruleInstantiation
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getInstantiationsInstantiationParserRuleCall_3_1_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleInstantiation();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getInstantiationsInstantiationParserRuleCall_3_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__InstantiationsAssignment_3_1_0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0"
|
|
// InternalRDL.g:6968:1: rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0 : ( rulePropertyAssignment ) ;
|
|
public final void rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6972:1: ( ( rulePropertyAssignment ) )
|
|
// InternalRDL.g:6973:2: ( rulePropertyAssignment )
|
|
{
|
|
// InternalRDL.g:6973:2: ( rulePropertyAssignment )
|
|
// InternalRDL.g:6974:3: rulePropertyAssignment
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getPropertyAssignmentsPropertyAssignmentParserRuleCall_3_2_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyAssignment();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getPropertyAssignmentsPropertyAssignmentParserRuleCall_3_2_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__PropertyAssignmentsAssignment_3_2_0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0"
|
|
// InternalRDL.g:6983:1: rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0 : ( ruleEnumDefinition ) ;
|
|
public final void rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:6987:1: ( ( ruleEnumDefinition ) )
|
|
// InternalRDL.g:6988:2: ( ruleEnumDefinition )
|
|
{
|
|
// InternalRDL.g:6988:2: ( ruleEnumDefinition )
|
|
// InternalRDL.g:6989:3: ruleEnumDefinition
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getEnumDefinitionsEnumDefinitionParserRuleCall_3_3_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleEnumDefinition();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentDefinitionAccess().getEnumDefinitionsEnumDefinitionParserRuleCall_3_3_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentDefinition__EnumDefinitionsAssignment_3_3_0"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__InstanceTypeAssignment_0_0_0"
|
|
// InternalRDL.g:6998:1: rule__Instantiation__InstanceTypeAssignment_0_0_0 : ( ruleEnumInstanceType ) ;
|
|
public final void rule__Instantiation__InstanceTypeAssignment_0_0_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7002:1: ( ( ruleEnumInstanceType ) )
|
|
// InternalRDL.g:7003:2: ( ruleEnumInstanceType )
|
|
{
|
|
// InternalRDL.g:7003:2: ( ruleEnumInstanceType )
|
|
// InternalRDL.g:7004:3: ruleEnumInstanceType
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getInstanceTypeEnumInstanceTypeParserRuleCall_0_0_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleEnumInstanceType();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getInstanceTypeEnumInstanceTypeParserRuleCall_0_0_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__InstanceTypeAssignment_0_0_0"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__AliasAssignment_0_0_1_1"
|
|
// InternalRDL.g:7013:1: rule__Instantiation__AliasAssignment_0_0_1_1 : ( RULE_ID ) ;
|
|
public final void rule__Instantiation__AliasAssignment_0_0_1_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7017:1: ( ( RULE_ID ) )
|
|
// InternalRDL.g:7018:2: ( RULE_ID )
|
|
{
|
|
// InternalRDL.g:7018:2: ( RULE_ID )
|
|
// InternalRDL.g:7019:3: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getAliasIDTerminalRuleCall_0_0_1_1_0());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getAliasIDTerminalRuleCall_0_0_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__AliasAssignment_0_0_1_1"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__ComponentRefAssignment_0_0_2"
|
|
// InternalRDL.g:7028:1: rule__Instantiation__ComponentRefAssignment_0_0_2 : ( ( RULE_ID ) ) ;
|
|
public final void rule__Instantiation__ComponentRefAssignment_0_0_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7032:1: ( ( ( RULE_ID ) ) )
|
|
// InternalRDL.g:7033:2: ( ( RULE_ID ) )
|
|
{
|
|
// InternalRDL.g:7033:2: ( ( RULE_ID ) )
|
|
// InternalRDL.g:7034:3: ( RULE_ID )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getComponentRefComponentDefinitionCrossReference_0_0_2_0());
|
|
}
|
|
// InternalRDL.g:7035:3: ( RULE_ID )
|
|
// InternalRDL.g:7036:4: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getComponentRefComponentDefinitionIDTerminalRuleCall_0_0_2_0_1());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getComponentRefComponentDefinitionIDTerminalRuleCall_0_0_2_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getComponentRefComponentDefinitionCrossReference_0_0_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__ComponentRefAssignment_0_0_2"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__ComponentAssignment_0_1_0"
|
|
// InternalRDL.g:7047:1: rule__Instantiation__ComponentAssignment_0_1_0 : ( ruleComponentDefinition ) ;
|
|
public final void rule__Instantiation__ComponentAssignment_0_1_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7051:1: ( ( ruleComponentDefinition ) )
|
|
// InternalRDL.g:7052:2: ( ruleComponentDefinition )
|
|
{
|
|
// InternalRDL.g:7052:2: ( ruleComponentDefinition )
|
|
// InternalRDL.g:7053:3: ruleComponentDefinition
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getComponentComponentDefinitionParserRuleCall_0_1_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleComponentDefinition();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getComponentComponentDefinitionParserRuleCall_0_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__ComponentAssignment_0_1_0"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__InstanceTypeAssignment_0_1_1"
|
|
// InternalRDL.g:7062:1: rule__Instantiation__InstanceTypeAssignment_0_1_1 : ( ruleEnumInstanceType ) ;
|
|
public final void rule__Instantiation__InstanceTypeAssignment_0_1_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7066:1: ( ( ruleEnumInstanceType ) )
|
|
// InternalRDL.g:7067:2: ( ruleEnumInstanceType )
|
|
{
|
|
// InternalRDL.g:7067:2: ( ruleEnumInstanceType )
|
|
// InternalRDL.g:7068:3: ruleEnumInstanceType
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getInstanceTypeEnumInstanceTypeParserRuleCall_0_1_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleEnumInstanceType();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getInstanceTypeEnumInstanceTypeParserRuleCall_0_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__InstanceTypeAssignment_0_1_1"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__ComponentInstancesAssignment_1"
|
|
// InternalRDL.g:7077:1: rule__Instantiation__ComponentInstancesAssignment_1 : ( ruleComponentInstance ) ;
|
|
public final void rule__Instantiation__ComponentInstancesAssignment_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7081:1: ( ( ruleComponentInstance ) )
|
|
// InternalRDL.g:7082:2: ( ruleComponentInstance )
|
|
{
|
|
// InternalRDL.g:7082:2: ( ruleComponentInstance )
|
|
// InternalRDL.g:7083:3: ruleComponentInstance
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getComponentInstancesComponentInstanceParserRuleCall_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleComponentInstance();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getComponentInstancesComponentInstanceParserRuleCall_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__ComponentInstancesAssignment_1"
|
|
|
|
|
|
// $ANTLR start "rule__Instantiation__ComponentInstancesAssignment_2_1"
|
|
// InternalRDL.g:7092:1: rule__Instantiation__ComponentInstancesAssignment_2_1 : ( ruleComponentInstance ) ;
|
|
public final void rule__Instantiation__ComponentInstancesAssignment_2_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7096:1: ( ( ruleComponentInstance ) )
|
|
// InternalRDL.g:7097:2: ( ruleComponentInstance )
|
|
{
|
|
// InternalRDL.g:7097:2: ( ruleComponentInstance )
|
|
// InternalRDL.g:7098:3: ruleComponentInstance
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstantiationAccess().getComponentInstancesComponentInstanceParserRuleCall_2_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleComponentInstance();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstantiationAccess().getComponentInstancesComponentInstanceParserRuleCall_2_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Instantiation__ComponentInstancesAssignment_2_1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__NameAssignment_0"
|
|
// InternalRDL.g:7107:1: rule__ComponentInstance__NameAssignment_0 : ( RULE_ID ) ;
|
|
public final void rule__ComponentInstance__NameAssignment_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7111:1: ( ( RULE_ID ) )
|
|
// InternalRDL.g:7112:2: ( RULE_ID )
|
|
{
|
|
// InternalRDL.g:7112:2: ( RULE_ID )
|
|
// InternalRDL.g:7113:3: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getNameIDTerminalRuleCall_0_0());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getNameIDTerminalRuleCall_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__NameAssignment_0"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__RangeAssignment_1"
|
|
// InternalRDL.g:7122:1: rule__ComponentInstance__RangeAssignment_1 : ( ruleRange ) ;
|
|
public final void rule__ComponentInstance__RangeAssignment_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7126:1: ( ( ruleRange ) )
|
|
// InternalRDL.g:7127:2: ( ruleRange )
|
|
{
|
|
// InternalRDL.g:7127:2: ( ruleRange )
|
|
// InternalRDL.g:7128:3: ruleRange
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getRangeRangeParserRuleCall_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleRange();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getRangeRangeParserRuleCall_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__RangeAssignment_1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__ResetAssignment_2_1"
|
|
// InternalRDL.g:7137:1: rule__ComponentInstance__ResetAssignment_2_1 : ( RULE_NUM ) ;
|
|
public final void rule__ComponentInstance__ResetAssignment_2_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7141:1: ( ( RULE_NUM ) )
|
|
// InternalRDL.g:7142:2: ( RULE_NUM )
|
|
{
|
|
// InternalRDL.g:7142:2: ( RULE_NUM )
|
|
// InternalRDL.g:7143:3: RULE_NUM
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getResetNUMTerminalRuleCall_2_1_0());
|
|
}
|
|
match(input,RULE_NUM,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getResetNUMTerminalRuleCall_2_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__ResetAssignment_2_1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__AddressAssignment_3_1"
|
|
// InternalRDL.g:7152:1: rule__ComponentInstance__AddressAssignment_3_1 : ( RULE_NUM ) ;
|
|
public final void rule__ComponentInstance__AddressAssignment_3_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7156:1: ( ( RULE_NUM ) )
|
|
// InternalRDL.g:7157:2: ( RULE_NUM )
|
|
{
|
|
// InternalRDL.g:7157:2: ( RULE_NUM )
|
|
// InternalRDL.g:7158:3: RULE_NUM
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getAddressNUMTerminalRuleCall_3_1_0());
|
|
}
|
|
match(input,RULE_NUM,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getAddressNUMTerminalRuleCall_3_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__AddressAssignment_3_1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__AddrIncAssignment_4_1"
|
|
// InternalRDL.g:7167:1: rule__ComponentInstance__AddrIncAssignment_4_1 : ( RULE_NUM ) ;
|
|
public final void rule__ComponentInstance__AddrIncAssignment_4_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7171:1: ( ( RULE_NUM ) )
|
|
// InternalRDL.g:7172:2: ( RULE_NUM )
|
|
{
|
|
// InternalRDL.g:7172:2: ( RULE_NUM )
|
|
// InternalRDL.g:7173:3: RULE_NUM
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getAddrIncNUMTerminalRuleCall_4_1_0());
|
|
}
|
|
match(input,RULE_NUM,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getAddrIncNUMTerminalRuleCall_4_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__AddrIncAssignment_4_1"
|
|
|
|
|
|
// $ANTLR start "rule__ComponentInstance__AddrModAssignment_5_1"
|
|
// InternalRDL.g:7182:1: rule__ComponentInstance__AddrModAssignment_5_1 : ( RULE_NUM ) ;
|
|
public final void rule__ComponentInstance__AddrModAssignment_5_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7186:1: ( ( RULE_NUM ) )
|
|
// InternalRDL.g:7187:2: ( RULE_NUM )
|
|
{
|
|
// InternalRDL.g:7187:2: ( RULE_NUM )
|
|
// InternalRDL.g:7188:3: RULE_NUM
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentInstanceAccess().getAddrModNUMTerminalRuleCall_5_1_0());
|
|
}
|
|
match(input,RULE_NUM,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getComponentInstanceAccess().getAddrModNUMTerminalRuleCall_5_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ComponentInstance__AddrModAssignment_5_1"
|
|
|
|
|
|
// $ANTLR start "rule__Range__LeftAssignment_1_0_0"
|
|
// InternalRDL.g:7197:1: rule__Range__LeftAssignment_1_0_0 : ( RULE_NUM ) ;
|
|
public final void rule__Range__LeftAssignment_1_0_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7201:1: ( ( RULE_NUM ) )
|
|
// InternalRDL.g:7202:2: ( RULE_NUM )
|
|
{
|
|
// InternalRDL.g:7202:2: ( RULE_NUM )
|
|
// InternalRDL.g:7203:3: RULE_NUM
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getLeftNUMTerminalRuleCall_1_0_0_0());
|
|
}
|
|
match(input,RULE_NUM,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getLeftNUMTerminalRuleCall_1_0_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__LeftAssignment_1_0_0"
|
|
|
|
|
|
// $ANTLR start "rule__Range__RightAssignment_1_0_2"
|
|
// InternalRDL.g:7212:1: rule__Range__RightAssignment_1_0_2 : ( RULE_NUM ) ;
|
|
public final void rule__Range__RightAssignment_1_0_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7216:1: ( ( RULE_NUM ) )
|
|
// InternalRDL.g:7217:2: ( RULE_NUM )
|
|
{
|
|
// InternalRDL.g:7217:2: ( RULE_NUM )
|
|
// InternalRDL.g:7218:3: RULE_NUM
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getRightNUMTerminalRuleCall_1_0_2_0());
|
|
}
|
|
match(input,RULE_NUM,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getRightNUMTerminalRuleCall_1_0_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__RightAssignment_1_0_2"
|
|
|
|
|
|
// $ANTLR start "rule__Range__SizeAssignment_1_1"
|
|
// InternalRDL.g:7227:1: rule__Range__SizeAssignment_1_1 : ( RULE_NUM ) ;
|
|
public final void rule__Range__SizeAssignment_1_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7231:1: ( ( RULE_NUM ) )
|
|
// InternalRDL.g:7232:2: ( RULE_NUM )
|
|
{
|
|
// InternalRDL.g:7232:2: ( RULE_NUM )
|
|
// InternalRDL.g:7233:3: RULE_NUM
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRangeAccess().getSizeNUMTerminalRuleCall_1_1_0());
|
|
}
|
|
match(input,RULE_NUM,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getRangeAccess().getSizeNUMTerminalRuleCall_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Range__SizeAssignment_1_1"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__ModifierAssignment_0_0"
|
|
// InternalRDL.g:7242:1: rule__ExplicitPropertyAssignment__ModifierAssignment_0_0 : ( rulePropertyModifier ) ;
|
|
public final void rule__ExplicitPropertyAssignment__ModifierAssignment_0_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7246:1: ( ( rulePropertyModifier ) )
|
|
// InternalRDL.g:7247:2: ( rulePropertyModifier )
|
|
{
|
|
// InternalRDL.g:7247:2: ( rulePropertyModifier )
|
|
// InternalRDL.g:7248:3: rulePropertyModifier
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getModifierPropertyModifierEnumRuleCall_0_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyModifier();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getModifierPropertyModifierEnumRuleCall_0_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__ModifierAssignment_0_0"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__NameAssignment_0_1"
|
|
// InternalRDL.g:7257:1: rule__ExplicitPropertyAssignment__NameAssignment_0_1 : ( ruleProperty ) ;
|
|
public final void rule__ExplicitPropertyAssignment__NameAssignment_0_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7261:1: ( ( ruleProperty ) )
|
|
// InternalRDL.g:7262:2: ( ruleProperty )
|
|
{
|
|
// InternalRDL.g:7262:2: ( ruleProperty )
|
|
// InternalRDL.g:7263:3: ruleProperty
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getNamePropertyEnumRuleCall_0_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleProperty();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getNamePropertyEnumRuleCall_0_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__NameAssignment_0_1"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__NameAssignment_1_0"
|
|
// InternalRDL.g:7272:1: rule__ExplicitPropertyAssignment__NameAssignment_1_0 : ( ruleProperty ) ;
|
|
public final void rule__ExplicitPropertyAssignment__NameAssignment_1_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7276:1: ( ( ruleProperty ) )
|
|
// InternalRDL.g:7277:2: ( ruleProperty )
|
|
{
|
|
// InternalRDL.g:7277:2: ( ruleProperty )
|
|
// InternalRDL.g:7278:3: ruleProperty
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getNamePropertyEnumRuleCall_1_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleProperty();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getNamePropertyEnumRuleCall_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__NameAssignment_1_0"
|
|
|
|
|
|
// $ANTLR start "rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1"
|
|
// InternalRDL.g:7287:1: rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1 : ( rulePropertyAssignmentRhs ) ;
|
|
public final void rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7291:1: ( ( rulePropertyAssignmentRhs ) )
|
|
// InternalRDL.g:7292:2: ( rulePropertyAssignmentRhs )
|
|
{
|
|
// InternalRDL.g:7292:2: ( rulePropertyAssignmentRhs )
|
|
// InternalRDL.g:7293:3: rulePropertyAssignmentRhs
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getExplicitPropertyAssignmentAccess().getRhsPropertyAssignmentRhsParserRuleCall_1_1_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyAssignmentRhs();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getExplicitPropertyAssignmentAccess().getRhsPropertyAssignmentRhsParserRuleCall_1_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ExplicitPropertyAssignment__RhsAssignment_1_1_1"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__InstanceAssignment_0_0_0"
|
|
// InternalRDL.g:7302:1: rule__PostPropertyAssignment__InstanceAssignment_0_0_0 : ( ruleHierInstanceRef ) ;
|
|
public final void rule__PostPropertyAssignment__InstanceAssignment_0_0_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7306:1: ( ( ruleHierInstanceRef ) )
|
|
// InternalRDL.g:7307:2: ( ruleHierInstanceRef )
|
|
{
|
|
// InternalRDL.g:7307:2: ( ruleHierInstanceRef )
|
|
// InternalRDL.g:7308:3: ruleHierInstanceRef
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getInstanceHierInstanceRefParserRuleCall_0_0_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleHierInstanceRef();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getInstanceHierInstanceRefParserRuleCall_0_0_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__InstanceAssignment_0_0_0"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0"
|
|
// InternalRDL.g:7317:1: rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0 : ( ruleProperty ) ;
|
|
public final void rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7321:1: ( ( ruleProperty ) )
|
|
// InternalRDL.g:7322:2: ( ruleProperty )
|
|
{
|
|
// InternalRDL.g:7322:2: ( ruleProperty )
|
|
// InternalRDL.g:7323:3: ruleProperty
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getPropertyEnumPropertyEnumRuleCall_0_0_2_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleProperty();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getPropertyEnumPropertyEnumRuleCall_0_0_2_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__PropertyEnumAssignment_0_0_2_0"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1"
|
|
// InternalRDL.g:7332:1: rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1 : ( ( RULE_ID ) ) ;
|
|
public final void rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7336:1: ( ( ( RULE_ID ) ) )
|
|
// InternalRDL.g:7337:2: ( ( RULE_ID ) )
|
|
{
|
|
// InternalRDL.g:7337:2: ( ( RULE_ID ) )
|
|
// InternalRDL.g:7338:3: ( RULE_ID )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getPropertyPropertyDefinitionCrossReference_0_0_2_1_0());
|
|
}
|
|
// InternalRDL.g:7339:3: ( RULE_ID )
|
|
// InternalRDL.g:7340:4: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getPropertyPropertyDefinitionIDTerminalRuleCall_0_0_2_1_0_1());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getPropertyPropertyDefinitionIDTerminalRuleCall_0_0_2_1_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getPropertyPropertyDefinitionCrossReference_0_0_2_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__PropertyAssignment_0_0_2_1"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__PropertyAssignment_0_1"
|
|
// InternalRDL.g:7351:1: rule__PostPropertyAssignment__PropertyAssignment_0_1 : ( ( RULE_ID ) ) ;
|
|
public final void rule__PostPropertyAssignment__PropertyAssignment_0_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7355:1: ( ( ( RULE_ID ) ) )
|
|
// InternalRDL.g:7356:2: ( ( RULE_ID ) )
|
|
{
|
|
// InternalRDL.g:7356:2: ( ( RULE_ID ) )
|
|
// InternalRDL.g:7357:3: ( RULE_ID )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getPropertyPropertyDefinitionCrossReference_0_1_0());
|
|
}
|
|
// InternalRDL.g:7358:3: ( RULE_ID )
|
|
// InternalRDL.g:7359:4: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getPropertyPropertyDefinitionIDTerminalRuleCall_0_1_0_1());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getPropertyPropertyDefinitionIDTerminalRuleCall_0_1_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getPropertyPropertyDefinitionCrossReference_0_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__PropertyAssignment_0_1"
|
|
|
|
|
|
// $ANTLR start "rule__PostPropertyAssignment__RhsAssignment_1_1"
|
|
// InternalRDL.g:7370:1: rule__PostPropertyAssignment__RhsAssignment_1_1 : ( rulePropertyAssignmentRhs ) ;
|
|
public final void rule__PostPropertyAssignment__RhsAssignment_1_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7374:1: ( ( rulePropertyAssignmentRhs ) )
|
|
// InternalRDL.g:7375:2: ( rulePropertyAssignmentRhs )
|
|
{
|
|
// InternalRDL.g:7375:2: ( rulePropertyAssignmentRhs )
|
|
// InternalRDL.g:7376:3: rulePropertyAssignmentRhs
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPostPropertyAssignmentAccess().getRhsPropertyAssignmentRhsParserRuleCall_1_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyAssignmentRhs();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPostPropertyAssignmentAccess().getRhsPropertyAssignmentRhsParserRuleCall_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PostPropertyAssignment__RhsAssignment_1_1"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__InstanceAssignment_0"
|
|
// InternalRDL.g:7385:1: rule__InstancePropertyRef__InstanceAssignment_0 : ( ruleInstanceRef ) ;
|
|
public final void rule__InstancePropertyRef__InstanceAssignment_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7389:1: ( ( ruleInstanceRef ) )
|
|
// InternalRDL.g:7390:2: ( ruleInstanceRef )
|
|
{
|
|
// InternalRDL.g:7390:2: ( ruleInstanceRef )
|
|
// InternalRDL.g:7391:3: ruleInstanceRef
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefAccess().getInstanceInstanceRefParserRuleCall_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleInstanceRef();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefAccess().getInstanceInstanceRefParserRuleCall_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstancePropertyRef__InstanceAssignment_0"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0"
|
|
// InternalRDL.g:7400:1: rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0 : ( ruleProperty ) ;
|
|
public final void rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7404:1: ( ( ruleProperty ) )
|
|
// InternalRDL.g:7405:2: ( ruleProperty )
|
|
{
|
|
// InternalRDL.g:7405:2: ( ruleProperty )
|
|
// InternalRDL.g:7406:3: ruleProperty
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefAccess().getPropertyEnumPropertyEnumRuleCall_1_1_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleProperty();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefAccess().getPropertyEnumPropertyEnumRuleCall_1_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstancePropertyRef__PropertyEnumAssignment_1_1_0"
|
|
|
|
|
|
// $ANTLR start "rule__InstancePropertyRef__PropertyAssignment_1_1_1"
|
|
// InternalRDL.g:7415:1: rule__InstancePropertyRef__PropertyAssignment_1_1_1 : ( ( RULE_ID ) ) ;
|
|
public final void rule__InstancePropertyRef__PropertyAssignment_1_1_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7419:1: ( ( ( RULE_ID ) ) )
|
|
// InternalRDL.g:7420:2: ( ( RULE_ID ) )
|
|
{
|
|
// InternalRDL.g:7420:2: ( ( RULE_ID ) )
|
|
// InternalRDL.g:7421:3: ( RULE_ID )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefAccess().getPropertyPropertyDefinitionCrossReference_1_1_1_0());
|
|
}
|
|
// InternalRDL.g:7422:3: ( RULE_ID )
|
|
// InternalRDL.g:7423:4: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstancePropertyRefAccess().getPropertyPropertyDefinitionIDTerminalRuleCall_1_1_1_0_1());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefAccess().getPropertyPropertyDefinitionIDTerminalRuleCall_1_1_1_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstancePropertyRefAccess().getPropertyPropertyDefinitionCrossReference_1_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstancePropertyRef__PropertyAssignment_1_1_1"
|
|
|
|
|
|
// $ANTLR start "rule__InstanceRef__InstanceAssignment_0"
|
|
// InternalRDL.g:7434:1: rule__InstanceRef__InstanceAssignment_0 : ( ( RULE_ID ) ) ;
|
|
public final void rule__InstanceRef__InstanceAssignment_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7438:1: ( ( ( RULE_ID ) ) )
|
|
// InternalRDL.g:7439:2: ( ( RULE_ID ) )
|
|
{
|
|
// InternalRDL.g:7439:2: ( ( RULE_ID ) )
|
|
// InternalRDL.g:7440:3: ( RULE_ID )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstanceRefAccess().getInstanceEntityCrossReference_0_0());
|
|
}
|
|
// InternalRDL.g:7441:3: ( RULE_ID )
|
|
// InternalRDL.g:7442:4: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstanceRefAccess().getInstanceEntityIDTerminalRuleCall_0_0_1());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstanceRefAccess().getInstanceEntityIDTerminalRuleCall_0_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstanceRefAccess().getInstanceEntityCrossReference_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstanceRef__InstanceAssignment_0"
|
|
|
|
|
|
// $ANTLR start "rule__InstanceRef__TailAssignment_1_1"
|
|
// InternalRDL.g:7453:1: rule__InstanceRef__TailAssignment_1_1 : ( ruleHierInstanceRef ) ;
|
|
public final void rule__InstanceRef__TailAssignment_1_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7457:1: ( ( ruleHierInstanceRef ) )
|
|
// InternalRDL.g:7458:2: ( ruleHierInstanceRef )
|
|
{
|
|
// InternalRDL.g:7458:2: ( ruleHierInstanceRef )
|
|
// InternalRDL.g:7459:3: ruleHierInstanceRef
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getInstanceRefAccess().getTailHierInstanceRefParserRuleCall_1_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleHierInstanceRef();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getInstanceRefAccess().getTailHierInstanceRefParserRuleCall_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__InstanceRef__TailAssignment_1_1"
|
|
|
|
|
|
// $ANTLR start "rule__HierInstanceRef__InstanceAssignment_0"
|
|
// InternalRDL.g:7468:1: rule__HierInstanceRef__InstanceAssignment_0 : ( ( RULE_ID ) ) ;
|
|
public final void rule__HierInstanceRef__InstanceAssignment_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7472:1: ( ( ( RULE_ID ) ) )
|
|
// InternalRDL.g:7473:2: ( ( RULE_ID ) )
|
|
{
|
|
// InternalRDL.g:7473:2: ( ( RULE_ID ) )
|
|
// InternalRDL.g:7474:3: ( RULE_ID )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getHierInstanceRefAccess().getInstanceComponentInstanceCrossReference_0_0());
|
|
}
|
|
// InternalRDL.g:7475:3: ( RULE_ID )
|
|
// InternalRDL.g:7476:4: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getHierInstanceRefAccess().getInstanceComponentInstanceIDTerminalRuleCall_0_0_1());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getHierInstanceRefAccess().getInstanceComponentInstanceIDTerminalRuleCall_0_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getHierInstanceRefAccess().getInstanceComponentInstanceCrossReference_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__HierInstanceRef__InstanceAssignment_0"
|
|
|
|
|
|
// $ANTLR start "rule__HierInstanceRef__TailAssignment_1_1"
|
|
// InternalRDL.g:7487:1: rule__HierInstanceRef__TailAssignment_1_1 : ( ruleHierInstanceRef ) ;
|
|
public final void rule__HierInstanceRef__TailAssignment_1_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7491:1: ( ( ruleHierInstanceRef ) )
|
|
// InternalRDL.g:7492:2: ( ruleHierInstanceRef )
|
|
{
|
|
// InternalRDL.g:7492:2: ( ruleHierInstanceRef )
|
|
// InternalRDL.g:7493:3: ruleHierInstanceRef
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getHierInstanceRefAccess().getTailHierInstanceRefParserRuleCall_1_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleHierInstanceRef();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getHierInstanceRefAccess().getTailHierInstanceRefParserRuleCall_1_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__HierInstanceRef__TailAssignment_1_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__ValueAssignment_0"
|
|
// InternalRDL.g:7502:1: rule__PropertyAssignmentRhs__ValueAssignment_0 : ( rulePropertyRvalueConstant ) ;
|
|
public final void rule__PropertyAssignmentRhs__ValueAssignment_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7506:1: ( ( rulePropertyRvalueConstant ) )
|
|
// InternalRDL.g:7507:2: ( rulePropertyRvalueConstant )
|
|
{
|
|
// InternalRDL.g:7507:2: ( rulePropertyRvalueConstant )
|
|
// InternalRDL.g:7508:3: rulePropertyRvalueConstant
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getValuePropertyRvalueConstantParserRuleCall_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
rulePropertyRvalueConstant();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getValuePropertyRvalueConstantParserRuleCall_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__ValueAssignment_0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__InstPropRefAssignment_1"
|
|
// InternalRDL.g:7517:1: rule__PropertyAssignmentRhs__InstPropRefAssignment_1 : ( ruleInstancePropertyRef ) ;
|
|
public final void rule__PropertyAssignmentRhs__InstPropRefAssignment_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7521:1: ( ( ruleInstancePropertyRef ) )
|
|
// InternalRDL.g:7522:2: ( ruleInstancePropertyRef )
|
|
{
|
|
// InternalRDL.g:7522:2: ( ruleInstancePropertyRef )
|
|
// InternalRDL.g:7523:3: ruleInstancePropertyRef
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getInstPropRefInstancePropertyRefParserRuleCall_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleInstancePropertyRef();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getInstPropRefInstancePropertyRefParserRuleCall_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__InstPropRefAssignment_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__EnumRefAssignment_2_0"
|
|
// InternalRDL.g:7532:1: rule__PropertyAssignmentRhs__EnumRefAssignment_2_0 : ( ( RULE_ID ) ) ;
|
|
public final void rule__PropertyAssignmentRhs__EnumRefAssignment_2_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7536:1: ( ( ( RULE_ID ) ) )
|
|
// InternalRDL.g:7537:2: ( ( RULE_ID ) )
|
|
{
|
|
// InternalRDL.g:7537:2: ( ( RULE_ID ) )
|
|
// InternalRDL.g:7538:3: ( RULE_ID )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getEnumRefEnumDefinitionCrossReference_2_0_0());
|
|
}
|
|
// InternalRDL.g:7539:3: ( RULE_ID )
|
|
// InternalRDL.g:7540:4: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getEnumRefEnumDefinitionIDTerminalRuleCall_2_0_0_1());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getEnumRefEnumDefinitionIDTerminalRuleCall_2_0_0_1());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getEnumRefEnumDefinitionCrossReference_2_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__EnumRefAssignment_2_0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__EnumsAssignment_2_2"
|
|
// InternalRDL.g:7551:1: rule__PropertyAssignmentRhs__EnumsAssignment_2_2 : ( ruleEnumBody ) ;
|
|
public final void rule__PropertyAssignmentRhs__EnumsAssignment_2_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7555:1: ( ( ruleEnumBody ) )
|
|
// InternalRDL.g:7556:2: ( ruleEnumBody )
|
|
{
|
|
// InternalRDL.g:7556:2: ( ruleEnumBody )
|
|
// InternalRDL.g:7557:3: ruleEnumBody
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getEnumsEnumBodyParserRuleCall_2_2_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleEnumBody();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getEnumsEnumBodyParserRuleCall_2_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__EnumsAssignment_2_2"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyAssignmentRhs__ElementsAssignment_3"
|
|
// InternalRDL.g:7566:1: rule__PropertyAssignmentRhs__ElementsAssignment_3 : ( ruleConcat ) ;
|
|
public final void rule__PropertyAssignmentRhs__ElementsAssignment_3() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7570:1: ( ( ruleConcat ) )
|
|
// InternalRDL.g:7571:2: ( ruleConcat )
|
|
{
|
|
// InternalRDL.g:7571:2: ( ruleConcat )
|
|
// InternalRDL.g:7572:3: ruleConcat
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyAssignmentRhsAccess().getElementsConcatParserRuleCall_3_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleConcat();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyAssignmentRhsAccess().getElementsConcatParserRuleCall_3_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyAssignmentRhs__ElementsAssignment_3"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__ElementsAssignment_1"
|
|
// InternalRDL.g:7581:1: rule__Concat__ElementsAssignment_1 : ( ruleConcatElem ) ;
|
|
public final void rule__Concat__ElementsAssignment_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7585:1: ( ( ruleConcatElem ) )
|
|
// InternalRDL.g:7586:2: ( ruleConcatElem )
|
|
{
|
|
// InternalRDL.g:7586:2: ( ruleConcatElem )
|
|
// InternalRDL.g:7587:3: ruleConcatElem
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatAccess().getElementsConcatElemParserRuleCall_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleConcatElem();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatAccess().getElementsConcatElemParserRuleCall_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__ElementsAssignment_1"
|
|
|
|
|
|
// $ANTLR start "rule__Concat__ElementsAssignment_2_1"
|
|
// InternalRDL.g:7596:1: rule__Concat__ElementsAssignment_2_1 : ( ruleConcatElem ) ;
|
|
public final void rule__Concat__ElementsAssignment_2_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7600:1: ( ( ruleConcatElem ) )
|
|
// InternalRDL.g:7601:2: ( ruleConcatElem )
|
|
{
|
|
// InternalRDL.g:7601:2: ( ruleConcatElem )
|
|
// InternalRDL.g:7602:3: ruleConcatElem
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatAccess().getElementsConcatElemParserRuleCall_2_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleConcatElem();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatAccess().getElementsConcatElemParserRuleCall_2_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__Concat__ElementsAssignment_2_1"
|
|
|
|
|
|
// $ANTLR start "rule__ConcatElem__InstPropRefAssignment_0"
|
|
// InternalRDL.g:7611:1: rule__ConcatElem__InstPropRefAssignment_0 : ( ruleInstancePropertyRef ) ;
|
|
public final void rule__ConcatElem__InstPropRefAssignment_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7615:1: ( ( ruleInstancePropertyRef ) )
|
|
// InternalRDL.g:7616:2: ( ruleInstancePropertyRef )
|
|
{
|
|
// InternalRDL.g:7616:2: ( ruleInstancePropertyRef )
|
|
// InternalRDL.g:7617:3: ruleInstancePropertyRef
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatElemAccess().getInstPropRefInstancePropertyRefParserRuleCall_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleInstancePropertyRef();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatElemAccess().getInstPropRefInstancePropertyRefParserRuleCall_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ConcatElem__InstPropRefAssignment_0"
|
|
|
|
|
|
// $ANTLR start "rule__ConcatElem__ValueAssignment_1"
|
|
// InternalRDL.g:7626:1: rule__ConcatElem__ValueAssignment_1 : ( RULE_NUM ) ;
|
|
public final void rule__ConcatElem__ValueAssignment_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7630:1: ( ( RULE_NUM ) )
|
|
// InternalRDL.g:7631:2: ( RULE_NUM )
|
|
{
|
|
// InternalRDL.g:7631:2: ( RULE_NUM )
|
|
// InternalRDL.g:7632:3: RULE_NUM
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getConcatElemAccess().getValueNUMTerminalRuleCall_1_0());
|
|
}
|
|
match(input,RULE_NUM,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getConcatElemAccess().getValueNUMTerminalRuleCall_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__ConcatElem__ValueAssignment_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyRvalueConstant__ValAssignment_0"
|
|
// InternalRDL.g:7641:1: rule__PropertyRvalueConstant__ValAssignment_0 : ( ruleRValueConstant ) ;
|
|
public final void rule__PropertyRvalueConstant__ValAssignment_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7645:1: ( ( ruleRValueConstant ) )
|
|
// InternalRDL.g:7646:2: ( ruleRValueConstant )
|
|
{
|
|
// InternalRDL.g:7646:2: ( ruleRValueConstant )
|
|
// InternalRDL.g:7647:3: ruleRValueConstant
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyRvalueConstantAccess().getValRValueConstantEnumRuleCall_0_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleRValueConstant();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyRvalueConstantAccess().getValRValueConstantEnumRuleCall_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyRvalueConstant__ValAssignment_0"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyRvalueConstant__NumAssignment_1"
|
|
// InternalRDL.g:7656:1: rule__PropertyRvalueConstant__NumAssignment_1 : ( RULE_NUM ) ;
|
|
public final void rule__PropertyRvalueConstant__NumAssignment_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7660:1: ( ( RULE_NUM ) )
|
|
// InternalRDL.g:7661:2: ( RULE_NUM )
|
|
{
|
|
// InternalRDL.g:7661:2: ( RULE_NUM )
|
|
// InternalRDL.g:7662:3: RULE_NUM
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyRvalueConstantAccess().getNumNUMTerminalRuleCall_1_0());
|
|
}
|
|
match(input,RULE_NUM,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyRvalueConstantAccess().getNumNUMTerminalRuleCall_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyRvalueConstant__NumAssignment_1"
|
|
|
|
|
|
// $ANTLR start "rule__PropertyRvalueConstant__StrAssignment_2"
|
|
// InternalRDL.g:7671:1: rule__PropertyRvalueConstant__StrAssignment_2 : ( RULE_STR ) ;
|
|
public final void rule__PropertyRvalueConstant__StrAssignment_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7675:1: ( ( RULE_STR ) )
|
|
// InternalRDL.g:7676:2: ( RULE_STR )
|
|
{
|
|
// InternalRDL.g:7676:2: ( RULE_STR )
|
|
// InternalRDL.g:7677:3: RULE_STR
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getPropertyRvalueConstantAccess().getStrSTRTerminalRuleCall_2_0());
|
|
}
|
|
match(input,RULE_STR,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getPropertyRvalueConstantAccess().getStrSTRTerminalRuleCall_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__PropertyRvalueConstant__StrAssignment_2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumDefinition__NameAssignment_1"
|
|
// InternalRDL.g:7686:1: rule__EnumDefinition__NameAssignment_1 : ( RULE_ID ) ;
|
|
public final void rule__EnumDefinition__NameAssignment_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7690:1: ( ( RULE_ID ) )
|
|
// InternalRDL.g:7691:2: ( RULE_ID )
|
|
{
|
|
// InternalRDL.g:7691:2: ( RULE_ID )
|
|
// InternalRDL.g:7692:3: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumDefinitionAccess().getNameIDTerminalRuleCall_1_0());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumDefinitionAccess().getNameIDTerminalRuleCall_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumDefinition__NameAssignment_1"
|
|
|
|
|
|
// $ANTLR start "rule__EnumDefinition__BodyAssignment_2"
|
|
// InternalRDL.g:7701:1: rule__EnumDefinition__BodyAssignment_2 : ( ruleEnumBody ) ;
|
|
public final void rule__EnumDefinition__BodyAssignment_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7705:1: ( ( ruleEnumBody ) )
|
|
// InternalRDL.g:7706:2: ( ruleEnumBody )
|
|
{
|
|
// InternalRDL.g:7706:2: ( ruleEnumBody )
|
|
// InternalRDL.g:7707:3: ruleEnumBody
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumDefinitionAccess().getBodyEnumBodyParserRuleCall_2_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleEnumBody();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumDefinitionAccess().getBodyEnumBodyParserRuleCall_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumDefinition__BodyAssignment_2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumBody__EntriesAssignment_2"
|
|
// InternalRDL.g:7716:1: rule__EnumBody__EntriesAssignment_2 : ( ruleEnumEntry ) ;
|
|
public final void rule__EnumBody__EntriesAssignment_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7720:1: ( ( ruleEnumEntry ) )
|
|
// InternalRDL.g:7721:2: ( ruleEnumEntry )
|
|
{
|
|
// InternalRDL.g:7721:2: ( ruleEnumEntry )
|
|
// InternalRDL.g:7722:3: ruleEnumEntry
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumBodyAccess().getEntriesEnumEntryParserRuleCall_2_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleEnumEntry();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumBodyAccess().getEntriesEnumEntryParserRuleCall_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumBody__EntriesAssignment_2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__NameAssignment_0"
|
|
// InternalRDL.g:7731:1: rule__EnumEntry__NameAssignment_0 : ( RULE_ID ) ;
|
|
public final void rule__EnumEntry__NameAssignment_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7735:1: ( ( RULE_ID ) )
|
|
// InternalRDL.g:7736:2: ( RULE_ID )
|
|
{
|
|
// InternalRDL.g:7736:2: ( RULE_ID )
|
|
// InternalRDL.g:7737:3: RULE_ID
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getNameIDTerminalRuleCall_0_0());
|
|
}
|
|
match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getNameIDTerminalRuleCall_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__NameAssignment_0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__IndexAssignment_2"
|
|
// InternalRDL.g:7746:1: rule__EnumEntry__IndexAssignment_2 : ( RULE_NUM ) ;
|
|
public final void rule__EnumEntry__IndexAssignment_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7750:1: ( ( RULE_NUM ) )
|
|
// InternalRDL.g:7751:2: ( RULE_NUM )
|
|
{
|
|
// InternalRDL.g:7751:2: ( RULE_NUM )
|
|
// InternalRDL.g:7752:3: RULE_NUM
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getIndexNUMTerminalRuleCall_2_0());
|
|
}
|
|
match(input,RULE_NUM,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getIndexNUMTerminalRuleCall_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__IndexAssignment_2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumEntry__PropertiesAssignment_3_1"
|
|
// InternalRDL.g:7761:1: rule__EnumEntry__PropertiesAssignment_3_1 : ( ruleEnumProperty ) ;
|
|
public final void rule__EnumEntry__PropertiesAssignment_3_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7765:1: ( ( ruleEnumProperty ) )
|
|
// InternalRDL.g:7766:2: ( ruleEnumProperty )
|
|
{
|
|
// InternalRDL.g:7766:2: ( ruleEnumProperty )
|
|
// InternalRDL.g:7767:3: ruleEnumProperty
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumEntryAccess().getPropertiesEnumPropertyParserRuleCall_3_1_0());
|
|
}
|
|
pushFollow(FOLLOW_2);
|
|
ruleEnumProperty();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumEntryAccess().getPropertiesEnumPropertyParserRuleCall_3_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumEntry__PropertiesAssignment_3_1"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__NameAssignment_0_0_0"
|
|
// InternalRDL.g:7776:1: rule__EnumProperty__NameAssignment_0_0_0 : ( ( 'name' ) ) ;
|
|
public final void rule__EnumProperty__NameAssignment_0_0_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7780:1: ( ( ( 'name' ) ) )
|
|
// InternalRDL.g:7781:2: ( ( 'name' ) )
|
|
{
|
|
// InternalRDL.g:7781:2: ( ( 'name' ) )
|
|
// InternalRDL.g:7782:3: ( 'name' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getNameNameKeyword_0_0_0_0());
|
|
}
|
|
// InternalRDL.g:7783:3: ( 'name' )
|
|
// InternalRDL.g:7784:4: 'name'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getNameNameKeyword_0_0_0_0());
|
|
}
|
|
match(input,22,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getNameNameKeyword_0_0_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getNameNameKeyword_0_0_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__NameAssignment_0_0_0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__ValueAssignment_0_0_2"
|
|
// InternalRDL.g:7795:1: rule__EnumProperty__ValueAssignment_0_0_2 : ( RULE_STR ) ;
|
|
public final void rule__EnumProperty__ValueAssignment_0_0_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7799:1: ( ( RULE_STR ) )
|
|
// InternalRDL.g:7800:2: ( RULE_STR )
|
|
{
|
|
// InternalRDL.g:7800:2: ( RULE_STR )
|
|
// InternalRDL.g:7801:3: RULE_STR
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getValueSTRTerminalRuleCall_0_0_2_0());
|
|
}
|
|
match(input,RULE_STR,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getValueSTRTerminalRuleCall_0_0_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__ValueAssignment_0_0_2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__NameAssignment_0_1_0"
|
|
// InternalRDL.g:7810:1: rule__EnumProperty__NameAssignment_0_1_0 : ( ( 'desc' ) ) ;
|
|
public final void rule__EnumProperty__NameAssignment_0_1_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7814:1: ( ( ( 'desc' ) ) )
|
|
// InternalRDL.g:7815:2: ( ( 'desc' ) )
|
|
{
|
|
// InternalRDL.g:7815:2: ( ( 'desc' ) )
|
|
// InternalRDL.g:7816:3: ( 'desc' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getNameDescKeyword_0_1_0_0());
|
|
}
|
|
// InternalRDL.g:7817:3: ( 'desc' )
|
|
// InternalRDL.g:7818:4: 'desc'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getNameDescKeyword_0_1_0_0());
|
|
}
|
|
match(input,23,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getNameDescKeyword_0_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getNameDescKeyword_0_1_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__NameAssignment_0_1_0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumProperty__ValueAssignment_0_1_2"
|
|
// InternalRDL.g:7829:1: rule__EnumProperty__ValueAssignment_0_1_2 : ( RULE_STR ) ;
|
|
public final void rule__EnumProperty__ValueAssignment_0_1_2() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7833:1: ( ( RULE_STR ) )
|
|
// InternalRDL.g:7834:2: ( RULE_STR )
|
|
{
|
|
// InternalRDL.g:7834:2: ( RULE_STR )
|
|
// InternalRDL.g:7835:3: RULE_STR
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumPropertyAccess().getValueSTRTerminalRuleCall_0_1_2_0());
|
|
}
|
|
match(input,RULE_STR,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumPropertyAccess().getValueSTRTerminalRuleCall_0_1_2_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumProperty__ValueAssignment_0_1_2"
|
|
|
|
|
|
// $ANTLR start "rule__EnumInstanceType__EXTERNALAssignment_0"
|
|
// InternalRDL.g:7844:1: rule__EnumInstanceType__EXTERNALAssignment_0 : ( ( 'external' ) ) ;
|
|
public final void rule__EnumInstanceType__EXTERNALAssignment_0() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7848:1: ( ( ( 'external' ) ) )
|
|
// InternalRDL.g:7849:2: ( ( 'external' ) )
|
|
{
|
|
// InternalRDL.g:7849:2: ( ( 'external' ) )
|
|
// InternalRDL.g:7850:3: ( 'external' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumInstanceTypeAccess().getEXTERNALExternalKeyword_0_0());
|
|
}
|
|
// InternalRDL.g:7851:3: ( 'external' )
|
|
// InternalRDL.g:7852:4: 'external'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumInstanceTypeAccess().getEXTERNALExternalKeyword_0_0());
|
|
}
|
|
match(input,134,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumInstanceTypeAccess().getEXTERNALExternalKeyword_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumInstanceTypeAccess().getEXTERNALExternalKeyword_0_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumInstanceType__EXTERNALAssignment_0"
|
|
|
|
|
|
// $ANTLR start "rule__EnumInstanceType__INTERNALAssignment_1"
|
|
// InternalRDL.g:7863:1: rule__EnumInstanceType__INTERNALAssignment_1 : ( ( 'internal' ) ) ;
|
|
public final void rule__EnumInstanceType__INTERNALAssignment_1() throws RecognitionException {
|
|
|
|
int stackSize = keepStackSize();
|
|
|
|
try {
|
|
// InternalRDL.g:7867:1: ( ( ( 'internal' ) ) )
|
|
// InternalRDL.g:7868:2: ( ( 'internal' ) )
|
|
{
|
|
// InternalRDL.g:7868:2: ( ( 'internal' ) )
|
|
// InternalRDL.g:7869:3: ( 'internal' )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumInstanceTypeAccess().getINTERNALInternalKeyword_1_0());
|
|
}
|
|
// InternalRDL.g:7870:3: ( 'internal' )
|
|
// InternalRDL.g:7871:4: 'internal'
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getEnumInstanceTypeAccess().getINTERNALInternalKeyword_1_0());
|
|
}
|
|
match(input,76,FOLLOW_2); if (state.failed) return ;
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumInstanceTypeAccess().getINTERNALInternalKeyword_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
if ( state.backtracking==0 ) {
|
|
after(grammarAccess.getEnumInstanceTypeAccess().getINTERNALInternalKeyword_1_0());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
}
|
|
finally {
|
|
|
|
restoreStackSize(stackSize);
|
|
|
|
}
|
|
return ;
|
|
}
|
|
// $ANTLR end "rule__EnumInstanceType__INTERNALAssignment_1"
|
|
|
|
// $ANTLR start synpred3_InternalRDL
|
|
public final void synpred3_InternalRDL_fragment() throws RecognitionException {
|
|
// InternalRDL.g:785:2: ( ( ( rule__Root__Group_1__0 ) ) )
|
|
// InternalRDL.g:785:2: ( ( rule__Root__Group_1__0 ) )
|
|
{
|
|
// InternalRDL.g:785:2: ( ( rule__Root__Group_1__0 ) )
|
|
// InternalRDL.g:786:3: ( rule__Root__Group_1__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getGroup_1());
|
|
}
|
|
// InternalRDL.g:787:3: ( rule__Root__Group_1__0 )
|
|
// InternalRDL.g:787:4: rule__Root__Group_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
// $ANTLR end synpred3_InternalRDL
|
|
|
|
// $ANTLR start synpred5_InternalRDL
|
|
public final void synpred5_InternalRDL_fragment() throws RecognitionException {
|
|
// InternalRDL.g:797:2: ( ( ( rule__Root__Group_3__0 ) ) )
|
|
// InternalRDL.g:797:2: ( ( rule__Root__Group_3__0 ) )
|
|
{
|
|
// InternalRDL.g:797:2: ( ( rule__Root__Group_3__0 ) )
|
|
// InternalRDL.g:798:3: ( rule__Root__Group_3__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getGroup_3());
|
|
}
|
|
// InternalRDL.g:799:3: ( rule__Root__Group_3__0 )
|
|
// InternalRDL.g:799:4: rule__Root__Group_3__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_3__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
// $ANTLR end synpred5_InternalRDL
|
|
|
|
// $ANTLR start synpred6_InternalRDL
|
|
public final void synpred6_InternalRDL_fragment() throws RecognitionException {
|
|
// InternalRDL.g:803:2: ( ( ( rule__Root__Group_4__0 ) ) )
|
|
// InternalRDL.g:803:2: ( ( rule__Root__Group_4__0 ) )
|
|
{
|
|
// InternalRDL.g:803:2: ( ( rule__Root__Group_4__0 ) )
|
|
// InternalRDL.g:804:3: ( rule__Root__Group_4__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getRootAccess().getGroup_4());
|
|
}
|
|
// InternalRDL.g:805:3: ( rule__Root__Group_4__0 )
|
|
// InternalRDL.g:805:4: rule__Root__Group_4__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__Root__Group_4__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
// $ANTLR end synpred6_InternalRDL
|
|
|
|
// $ANTLR start synpred15_InternalRDL
|
|
public final void synpred15_InternalRDL_fragment() throws RecognitionException {
|
|
// InternalRDL.g:947:2: ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) )
|
|
// InternalRDL.g:947:2: ( ( rule__ComponentDefinition__Group_3_0__0 ) )
|
|
{
|
|
// InternalRDL.g:947:2: ( ( rule__ComponentDefinition__Group_3_0__0 ) )
|
|
// InternalRDL.g:948:3: ( rule__ComponentDefinition__Group_3_0__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getGroup_3_0());
|
|
}
|
|
// InternalRDL.g:949:3: ( rule__ComponentDefinition__Group_3_0__0 )
|
|
// InternalRDL.g:949:4: rule__ComponentDefinition__Group_3_0__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_0__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
// $ANTLR end synpred15_InternalRDL
|
|
|
|
// $ANTLR start synpred16_InternalRDL
|
|
public final void synpred16_InternalRDL_fragment() throws RecognitionException {
|
|
// InternalRDL.g:953:2: ( ( ( rule__ComponentDefinition__Group_3_1__0 ) ) )
|
|
// InternalRDL.g:953:2: ( ( rule__ComponentDefinition__Group_3_1__0 ) )
|
|
{
|
|
// InternalRDL.g:953:2: ( ( rule__ComponentDefinition__Group_3_1__0 ) )
|
|
// InternalRDL.g:954:3: ( rule__ComponentDefinition__Group_3_1__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getGroup_3_1());
|
|
}
|
|
// InternalRDL.g:955:3: ( rule__ComponentDefinition__Group_3_1__0 )
|
|
// InternalRDL.g:955:4: rule__ComponentDefinition__Group_3_1__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_1__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
// $ANTLR end synpred16_InternalRDL
|
|
|
|
// $ANTLR start synpred17_InternalRDL
|
|
public final void synpred17_InternalRDL_fragment() throws RecognitionException {
|
|
// InternalRDL.g:959:2: ( ( ( rule__ComponentDefinition__Group_3_2__0 ) ) )
|
|
// InternalRDL.g:959:2: ( ( rule__ComponentDefinition__Group_3_2__0 ) )
|
|
{
|
|
// InternalRDL.g:959:2: ( ( rule__ComponentDefinition__Group_3_2__0 ) )
|
|
// InternalRDL.g:960:3: ( rule__ComponentDefinition__Group_3_2__0 )
|
|
{
|
|
if ( state.backtracking==0 ) {
|
|
before(grammarAccess.getComponentDefinitionAccess().getGroup_3_2());
|
|
}
|
|
// InternalRDL.g:961:3: ( rule__ComponentDefinition__Group_3_2__0 )
|
|
// InternalRDL.g:961:4: rule__ComponentDefinition__Group_3_2__0
|
|
{
|
|
pushFollow(FOLLOW_2);
|
|
rule__ComponentDefinition__Group_3_2__0();
|
|
|
|
state._fsp--;
|
|
if (state.failed) return ;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
// $ANTLR end synpred17_InternalRDL
|
|
|
|
// Delegated rules
|
|
|
|
public final boolean synpred15_InternalRDL() {
|
|
state.backtracking++;
|
|
int start = input.mark();
|
|
try {
|
|
synpred15_InternalRDL_fragment(); // can never throw exception
|
|
} catch (RecognitionException re) {
|
|
System.err.println("impossible: "+re);
|
|
}
|
|
boolean success = !state.failed;
|
|
input.rewind(start);
|
|
state.backtracking--;
|
|
state.failed=false;
|
|
return success;
|
|
}
|
|
public final boolean synpred17_InternalRDL() {
|
|
state.backtracking++;
|
|
int start = input.mark();
|
|
try {
|
|
synpred17_InternalRDL_fragment(); // can never throw exception
|
|
} catch (RecognitionException re) {
|
|
System.err.println("impossible: "+re);
|
|
}
|
|
boolean success = !state.failed;
|
|
input.rewind(start);
|
|
state.backtracking--;
|
|
state.failed=false;
|
|
return success;
|
|
}
|
|
public final boolean synpred3_InternalRDL() {
|
|
state.backtracking++;
|
|
int start = input.mark();
|
|
try {
|
|
synpred3_InternalRDL_fragment(); // can never throw exception
|
|
} catch (RecognitionException re) {
|
|
System.err.println("impossible: "+re);
|
|
}
|
|
boolean success = !state.failed;
|
|
input.rewind(start);
|
|
state.backtracking--;
|
|
state.failed=false;
|
|
return success;
|
|
}
|
|
public final boolean synpred16_InternalRDL() {
|
|
state.backtracking++;
|
|
int start = input.mark();
|
|
try {
|
|
synpred16_InternalRDL_fragment(); // can never throw exception
|
|
} catch (RecognitionException re) {
|
|
System.err.println("impossible: "+re);
|
|
}
|
|
boolean success = !state.failed;
|
|
input.rewind(start);
|
|
state.backtracking--;
|
|
state.failed=false;
|
|
return success;
|
|
}
|
|
public final boolean synpred6_InternalRDL() {
|
|
state.backtracking++;
|
|
int start = input.mark();
|
|
try {
|
|
synpred6_InternalRDL_fragment(); // can never throw exception
|
|
} catch (RecognitionException re) {
|
|
System.err.println("impossible: "+re);
|
|
}
|
|
boolean success = !state.failed;
|
|
input.rewind(start);
|
|
state.backtracking--;
|
|
state.failed=false;
|
|
return success;
|
|
}
|
|
public final boolean synpred5_InternalRDL() {
|
|
state.backtracking++;
|
|
int start = input.mark();
|
|
try {
|
|
synpred5_InternalRDL_fragment(); // can never throw exception
|
|
} catch (RecognitionException re) {
|
|
System.err.println("impossible: "+re);
|
|
}
|
|
boolean success = !state.failed;
|
|
input.rewind(start);
|
|
state.backtracking--;
|
|
state.failed=false;
|
|
return success;
|
|
}
|
|
|
|
|
|
protected DFA2 dfa2 = new DFA2(this);
|
|
protected DFA8 dfa8 = new DFA8(this);
|
|
static final String dfa_1s = "\137\uffff";
|
|
static final String dfa_2s = "\1\5\1\uffff\5\0\2\uffff\1\0\1\uffff\1\0\123\uffff";
|
|
static final String dfa_3s = "\1\u0086\1\uffff\5\0\2\uffff\1\0\1\uffff\1\0\123\uffff";
|
|
static final String dfa_4s = "\1\uffff\1\1\5\uffff\1\3\1\4\3\uffff\1\5\120\uffff\1\6\1\2";
|
|
static final String dfa_5s = "\2\uffff\1\0\1\1\1\2\1\3\1\4\2\uffff\1\5\1\uffff\1\6\123\uffff}>";
|
|
static final String[] dfa_6s = {
|
|
"\1\13\11\uffff\1\3\1\5\1\4\1\6\1\uffff\1\2\1\uffff\66\14\1\11\25\14\12\uffff\5\14\1\uffff\1\1\1\135\4\uffff\1\14\2\uffff\1\10\11\uffff\1\7\1\10",
|
|
"",
|
|
"\1\uffff",
|
|
"\1\uffff",
|
|
"\1\uffff",
|
|
"\1\uffff",
|
|
"\1\uffff",
|
|
"",
|
|
"",
|
|
"\1\uffff",
|
|
"",
|
|
"\1\uffff",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
};
|
|
|
|
static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s);
|
|
static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s);
|
|
static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s);
|
|
static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s);
|
|
static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s);
|
|
static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s);
|
|
|
|
class DFA2 extends DFA {
|
|
|
|
public DFA2(BaseRecognizer recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 2;
|
|
this.eot = dfa_1;
|
|
this.eof = dfa_1;
|
|
this.min = dfa_2;
|
|
this.max = dfa_3;
|
|
this.accept = dfa_4;
|
|
this.special = dfa_5;
|
|
this.transition = dfa_6;
|
|
}
|
|
public String getDescription() {
|
|
return "774:1: rule__Root__Alternatives : ( ( ( rule__Root__IncludesAssignment_0 ) ) | ( ( rule__Root__Group_1__0 ) ) | ( ( rule__Root__Group_2__0 ) ) | ( ( rule__Root__Group_3__0 ) ) | ( ( rule__Root__Group_4__0 ) ) | ( ( rule__Root__Group_5__0 ) ) );";
|
|
}
|
|
public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
|
|
TokenStream input = (TokenStream)_input;
|
|
int _s = s;
|
|
switch ( s ) {
|
|
case 0 :
|
|
int LA2_2 = input.LA(1);
|
|
|
|
|
|
int index2_2 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred3_InternalRDL()) ) {s = 94;}
|
|
|
|
else if ( (synpred5_InternalRDL()) ) {s = 8;}
|
|
|
|
|
|
input.seek(index2_2);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 1 :
|
|
int LA2_3 = input.LA(1);
|
|
|
|
|
|
int index2_3 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred3_InternalRDL()) ) {s = 94;}
|
|
|
|
else if ( (synpred5_InternalRDL()) ) {s = 8;}
|
|
|
|
|
|
input.seek(index2_3);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 2 :
|
|
int LA2_4 = input.LA(1);
|
|
|
|
|
|
int index2_4 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred3_InternalRDL()) ) {s = 94;}
|
|
|
|
else if ( (synpred5_InternalRDL()) ) {s = 8;}
|
|
|
|
|
|
input.seek(index2_4);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 3 :
|
|
int LA2_5 = input.LA(1);
|
|
|
|
|
|
int index2_5 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred3_InternalRDL()) ) {s = 94;}
|
|
|
|
else if ( (synpred5_InternalRDL()) ) {s = 8;}
|
|
|
|
|
|
input.seek(index2_5);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 4 :
|
|
int LA2_6 = input.LA(1);
|
|
|
|
|
|
int index2_6 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred3_InternalRDL()) ) {s = 94;}
|
|
|
|
else if ( (synpred5_InternalRDL()) ) {s = 8;}
|
|
|
|
|
|
input.seek(index2_6);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 5 :
|
|
int LA2_9 = input.LA(1);
|
|
|
|
|
|
int index2_9 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred5_InternalRDL()) ) {s = 8;}
|
|
|
|
else if ( (synpred6_InternalRDL()) ) {s = 12;}
|
|
|
|
|
|
input.seek(index2_9);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 6 :
|
|
int LA2_11 = input.LA(1);
|
|
|
|
|
|
int index2_11 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred5_InternalRDL()) ) {s = 8;}
|
|
|
|
else if ( (synpred6_InternalRDL()) ) {s = 12;}
|
|
|
|
|
|
input.seek(index2_11);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
}
|
|
if (state.backtracking>0) {state.failed=true; return -1;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException(getDescription(), 2, _s, input);
|
|
error(nvae);
|
|
throw nvae;
|
|
}
|
|
}
|
|
static final String dfa_7s = "\135\uffff";
|
|
static final String dfa_8s = "\1\5\5\0\1\uffff\1\0\1\uffff\1\0\123\uffff";
|
|
static final String dfa_9s = "\1\u0086\5\0\1\uffff\1\0\1\uffff\1\0\123\uffff";
|
|
static final String dfa_10s = "\6\uffff\1\2\3\uffff\1\3\120\uffff\1\4\1\1";
|
|
static final String dfa_11s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\uffff\1\5\1\uffff\1\6\123\uffff}>";
|
|
static final String[] dfa_12s = {
|
|
"\1\11\11\uffff\1\2\1\4\1\3\1\5\1\uffff\1\1\1\uffff\66\12\1\7\25\12\12\uffff\5\12\7\uffff\1\12\2\uffff\1\6\11\uffff\1\133\1\6",
|
|
"\1\uffff",
|
|
"\1\uffff",
|
|
"\1\uffff",
|
|
"\1\uffff",
|
|
"\1\uffff",
|
|
"",
|
|
"\1\uffff",
|
|
"",
|
|
"\1\uffff",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
};
|
|
|
|
static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s);
|
|
static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s);
|
|
static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s);
|
|
static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s);
|
|
static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s);
|
|
static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s);
|
|
|
|
class DFA8 extends DFA {
|
|
|
|
public DFA8(BaseRecognizer recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 8;
|
|
this.eot = dfa_7;
|
|
this.eof = dfa_7;
|
|
this.min = dfa_8;
|
|
this.max = dfa_9;
|
|
this.accept = dfa_10;
|
|
this.special = dfa_11;
|
|
this.transition = dfa_12;
|
|
}
|
|
public String getDescription() {
|
|
return "942:1: rule__ComponentDefinition__Alternatives_3 : ( ( ( rule__ComponentDefinition__Group_3_0__0 ) ) | ( ( rule__ComponentDefinition__Group_3_1__0 ) ) | ( ( rule__ComponentDefinition__Group_3_2__0 ) ) | ( ( rule__ComponentDefinition__Group_3_3__0 ) ) );";
|
|
}
|
|
public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
|
|
TokenStream input = (TokenStream)_input;
|
|
int _s = s;
|
|
switch ( s ) {
|
|
case 0 :
|
|
int LA8_1 = input.LA(1);
|
|
|
|
|
|
int index8_1 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred15_InternalRDL()) ) {s = 92;}
|
|
|
|
else if ( (synpred16_InternalRDL()) ) {s = 6;}
|
|
|
|
|
|
input.seek(index8_1);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 1 :
|
|
int LA8_2 = input.LA(1);
|
|
|
|
|
|
int index8_2 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred15_InternalRDL()) ) {s = 92;}
|
|
|
|
else if ( (synpred16_InternalRDL()) ) {s = 6;}
|
|
|
|
|
|
input.seek(index8_2);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 2 :
|
|
int LA8_3 = input.LA(1);
|
|
|
|
|
|
int index8_3 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred15_InternalRDL()) ) {s = 92;}
|
|
|
|
else if ( (synpred16_InternalRDL()) ) {s = 6;}
|
|
|
|
|
|
input.seek(index8_3);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 3 :
|
|
int LA8_4 = input.LA(1);
|
|
|
|
|
|
int index8_4 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred15_InternalRDL()) ) {s = 92;}
|
|
|
|
else if ( (synpred16_InternalRDL()) ) {s = 6;}
|
|
|
|
|
|
input.seek(index8_4);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 4 :
|
|
int LA8_5 = input.LA(1);
|
|
|
|
|
|
int index8_5 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred15_InternalRDL()) ) {s = 92;}
|
|
|
|
else if ( (synpred16_InternalRDL()) ) {s = 6;}
|
|
|
|
|
|
input.seek(index8_5);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 5 :
|
|
int LA8_7 = input.LA(1);
|
|
|
|
|
|
int index8_7 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred16_InternalRDL()) ) {s = 6;}
|
|
|
|
else if ( (synpred17_InternalRDL()) ) {s = 10;}
|
|
|
|
|
|
input.seek(index8_7);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
case 6 :
|
|
int LA8_9 = input.LA(1);
|
|
|
|
|
|
int index8_9 = input.index();
|
|
input.rewind();
|
|
s = -1;
|
|
if ( (synpred16_InternalRDL()) ) {s = 6;}
|
|
|
|
else if ( (synpred17_InternalRDL()) ) {s = 10;}
|
|
|
|
|
|
input.seek(index8_9);
|
|
if ( s>=0 ) return s;
|
|
break;
|
|
}
|
|
if (state.backtracking>0) {state.failed=true; return -1;}
|
|
NoViableAltException nvae =
|
|
new NoViableAltException(getDescription(), 8, _s, input);
|
|
error(nvae);
|
|
throw nvae;
|
|
}
|
|
}
|
|
|
|
|
|
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[]{0xFFFFFFFFFFD78022L,0x090DF003FFFFFFFFL,0x0000000000000060L});
|
|
public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000000L,0x0002000000000000L});
|
|
public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000010L});
|
|
public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000000020L});
|
|
public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L});
|
|
public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000000L,0x0340000000000000L});
|
|
public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L});
|
|
public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000000L,0x0080000000000000L});
|
|
public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x00000000000FF000L});
|
|
public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0200000000000000L});
|
|
public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000000L,0x0040000000000000L});
|
|
public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000000000L,0x0240000000000000L});
|
|
public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000000050L,0x0000000C00000000L});
|
|
public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000378000L});
|
|
public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000000L,0x0402000000000000L});
|
|
public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000000002L,0x0400000000000000L});
|
|
public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000000020L,0x0010000000000000L});
|
|
public static final BitSet FOLLOW_20 = new BitSet(new long[]{0xFFFFFFFFFFD78020L,0x0921F003FFFFFFFFL,0x0000000000000060L});
|
|
public static final BitSet FOLLOW_21 = new BitSet(new long[]{0xFFFFFFFFFFD78022L,0x0901F003FFFFFFFFL,0x0000000000000060L});
|
|
public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
|
|
public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000000002L,0x1000000000000000L});
|
|
public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000000020L,0x0800000000001000L,0x0000000000000040L});
|
|
public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L,0x0000000000000040L});
|
|
public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000000000L,0xE080000000000000L,0x0000000000000001L});
|
|
public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000000040L});
|
|
public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000002L});
|
|
public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000004L});
|
|
public static final BitSet FOLLOW_30 = new BitSet(new long[]{0xFFFFFFFFFFC00000L,0x0001F003FFFFFFFFL});
|
|
public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000000070L,0x00100FFE000C0000L});
|
|
public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000008L});
|
|
public static final BitSet FOLLOW_33 = new BitSet(new long[]{0xFFFFFFFFFFC00020L,0x0001F003FFFFFFFFL});
|
|
public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000010L});
|
|
public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
|
|
public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000000060L});
|
|
public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000000L,0x1020000000000000L});
|
|
public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000000020L,0x0020000000000000L});
|
|
public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000022L});
|
|
public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0012000000000000L});
|
|
public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000C00000L,0x0020000000000000L});
|
|
public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000C00002L});
|
|
|
|
} |