From 7e50434905cbb7f5d03636033b698e17a9075e9d Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Sat, 13 Jan 2018 19:33:26 +0100 Subject: Initial commit of the configuration language and application --- .../InternalApplicationConfigurationParser.java | 1746 ++++++++++++++++++++ 1 file changed, 1746 insertions(+) create mode 100644 Application/hu.bme.mit.inf.dslreasoner.application/src-gen/hu/bme/mit/inf/dslreasoner/application/parser/antlr/internal/InternalApplicationConfigurationParser.java (limited to 'Application/hu.bme.mit.inf.dslreasoner.application/src-gen/hu/bme/mit/inf/dslreasoner/application/parser/antlr/internal/InternalApplicationConfigurationParser.java') diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src-gen/hu/bme/mit/inf/dslreasoner/application/parser/antlr/internal/InternalApplicationConfigurationParser.java b/Application/hu.bme.mit.inf.dslreasoner.application/src-gen/hu/bme/mit/inf/dslreasoner/application/parser/antlr/internal/InternalApplicationConfigurationParser.java new file mode 100644 index 00000000..7387e45b --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src-gen/hu/bme/mit/inf/dslreasoner/application/parser/antlr/internal/InternalApplicationConfigurationParser.java @@ -0,0 +1,1746 @@ +package hu.bme.mit.inf.dslreasoner.application.parser.antlr.internal; + +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.AbstractInternalAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; +import hu.bme.mit.inf.dslreasoner.application.services.ApplicationConfigurationGrammarAccess; + + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalApplicationConfigurationParser extends AbstractInternalAntlrParser { + public static final String[] tokenNames = new String[] { + "", "", "", "", "RULE_STRING", "RULE_ID", "RULE_INT", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'import'", "'epackage'", "'viatra'", "'{'", "','", "'}'", "'package'", "'excluding'", "'::'", "'.'", "'metamodel'" + }; + public static final int RULE_STRING=4; + public static final int RULE_SL_COMMENT=8; + 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__11=11; + 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 EOF=-1; + public static final int RULE_ID=5; + public static final int RULE_WS=9; + public static final int RULE_ANY_OTHER=10; + public static final int RULE_INT=6; + public static final int RULE_ML_COMMENT=7; + public static final int T__20=20; + public static final int T__21=21; + + // delegates + // delegators + + + public InternalApplicationConfigurationParser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public InternalApplicationConfigurationParser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + + public String[] getTokenNames() { return InternalApplicationConfigurationParser.tokenNames; } + public String getGrammarFileName() { return "InternalApplicationConfiguration.g"; } + + + + private ApplicationConfigurationGrammarAccess grammarAccess; + + public InternalApplicationConfigurationParser(TokenStream input, ApplicationConfigurationGrammarAccess grammarAccess) { + this(input); + this.grammarAccess = grammarAccess; + registerRules(grammarAccess.getGrammar()); + } + + @Override + protected String getFirstRuleName() { + return "ConfigurationScript"; + } + + @Override + protected ApplicationConfigurationGrammarAccess getGrammarAccess() { + return grammarAccess; + } + + + + + // $ANTLR start "entryRuleConfigurationScript" + // InternalApplicationConfiguration.g:64:1: entryRuleConfigurationScript returns [EObject current=null] : iv_ruleConfigurationScript= ruleConfigurationScript EOF ; + public final EObject entryRuleConfigurationScript() throws RecognitionException { + EObject current = null; + + EObject iv_ruleConfigurationScript = null; + + + try { + // InternalApplicationConfiguration.g:64:60: (iv_ruleConfigurationScript= ruleConfigurationScript EOF ) + // InternalApplicationConfiguration.g:65:2: iv_ruleConfigurationScript= ruleConfigurationScript EOF + { + newCompositeNode(grammarAccess.getConfigurationScriptRule()); + pushFollow(FOLLOW_1); + iv_ruleConfigurationScript=ruleConfigurationScript(); + + state._fsp--; + + current =iv_ruleConfigurationScript; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleConfigurationScript" + + + // $ANTLR start "ruleConfigurationScript" + // InternalApplicationConfiguration.g:71:1: ruleConfigurationScript returns [EObject current=null] : ( ( (lv_imports_0_0= ruleImport ) )* ( (lv_commands_1_0= ruleCommand ) )* ) ; + public final EObject ruleConfigurationScript() throws RecognitionException { + EObject current = null; + + EObject lv_imports_0_0 = null; + + EObject lv_commands_1_0 = null; + + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:77:2: ( ( ( (lv_imports_0_0= ruleImport ) )* ( (lv_commands_1_0= ruleCommand ) )* ) ) + // InternalApplicationConfiguration.g:78:2: ( ( (lv_imports_0_0= ruleImport ) )* ( (lv_commands_1_0= ruleCommand ) )* ) + { + // InternalApplicationConfiguration.g:78:2: ( ( (lv_imports_0_0= ruleImport ) )* ( (lv_commands_1_0= ruleCommand ) )* ) + // InternalApplicationConfiguration.g:79:3: ( (lv_imports_0_0= ruleImport ) )* ( (lv_commands_1_0= ruleCommand ) )* + { + // InternalApplicationConfiguration.g:79:3: ( (lv_imports_0_0= ruleImport ) )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0==11) ) { + alt1=1; + } + + + switch (alt1) { + case 1 : + // InternalApplicationConfiguration.g:80:4: (lv_imports_0_0= ruleImport ) + { + // InternalApplicationConfiguration.g:80:4: (lv_imports_0_0= ruleImport ) + // InternalApplicationConfiguration.g:81:5: lv_imports_0_0= ruleImport + { + + newCompositeNode(grammarAccess.getConfigurationScriptAccess().getImportsImportParserRuleCall_0_0()); + + pushFollow(FOLLOW_3); + lv_imports_0_0=ruleImport(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConfigurationScriptRule()); + } + add( + current, + "imports", + lv_imports_0_0, + "hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration.Import"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop1; + } + } while (true); + + // InternalApplicationConfiguration.g:98:3: ( (lv_commands_1_0= ruleCommand ) )* + loop2: + do { + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0==21) ) { + alt2=1; + } + + + switch (alt2) { + case 1 : + // InternalApplicationConfiguration.g:99:4: (lv_commands_1_0= ruleCommand ) + { + // InternalApplicationConfiguration.g:99:4: (lv_commands_1_0= ruleCommand ) + // InternalApplicationConfiguration.g:100:5: lv_commands_1_0= ruleCommand + { + + newCompositeNode(grammarAccess.getConfigurationScriptAccess().getCommandsCommandParserRuleCall_1_0()); + + pushFollow(FOLLOW_4); + lv_commands_1_0=ruleCommand(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConfigurationScriptRule()); + } + add( + current, + "commands", + lv_commands_1_0, + "hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration.Command"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop2; + } + } while (true); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleConfigurationScript" + + + // $ANTLR start "entryRuleCommand" + // InternalApplicationConfiguration.g:121:1: entryRuleCommand returns [EObject current=null] : iv_ruleCommand= ruleCommand EOF ; + public final EObject entryRuleCommand() throws RecognitionException { + EObject current = null; + + EObject iv_ruleCommand = null; + + + try { + // InternalApplicationConfiguration.g:121:48: (iv_ruleCommand= ruleCommand EOF ) + // InternalApplicationConfiguration.g:122:2: iv_ruleCommand= ruleCommand EOF + { + newCompositeNode(grammarAccess.getCommandRule()); + pushFollow(FOLLOW_1); + iv_ruleCommand=ruleCommand(); + + state._fsp--; + + current =iv_ruleCommand; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleCommand" + + + // $ANTLR start "ruleCommand" + // InternalApplicationConfiguration.g:128:1: ruleCommand returns [EObject current=null] : this_Declaration_0= ruleDeclaration ; + public final EObject ruleCommand() throws RecognitionException { + EObject current = null; + + EObject this_Declaration_0 = null; + + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:134:2: (this_Declaration_0= ruleDeclaration ) + // InternalApplicationConfiguration.g:135:2: this_Declaration_0= ruleDeclaration + { + + newCompositeNode(grammarAccess.getCommandAccess().getDeclarationParserRuleCall()); + + pushFollow(FOLLOW_2); + this_Declaration_0=ruleDeclaration(); + + state._fsp--; + + + current = this_Declaration_0; + afterParserOrEnumRuleCall(); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleCommand" + + + // $ANTLR start "entryRuleDeclaration" + // InternalApplicationConfiguration.g:146:1: entryRuleDeclaration returns [EObject current=null] : iv_ruleDeclaration= ruleDeclaration EOF ; + public final EObject entryRuleDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleDeclaration = null; + + + try { + // InternalApplicationConfiguration.g:146:52: (iv_ruleDeclaration= ruleDeclaration EOF ) + // InternalApplicationConfiguration.g:147:2: iv_ruleDeclaration= ruleDeclaration EOF + { + newCompositeNode(grammarAccess.getDeclarationRule()); + pushFollow(FOLLOW_1); + iv_ruleDeclaration=ruleDeclaration(); + + state._fsp--; + + current =iv_ruleDeclaration; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleDeclaration" + + + // $ANTLR start "ruleDeclaration" + // InternalApplicationConfiguration.g:153:1: ruleDeclaration returns [EObject current=null] : this_MetamodelDeclaration_0= ruleMetamodelDeclaration ; + public final EObject ruleDeclaration() throws RecognitionException { + EObject current = null; + + EObject this_MetamodelDeclaration_0 = null; + + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:159:2: (this_MetamodelDeclaration_0= ruleMetamodelDeclaration ) + // InternalApplicationConfiguration.g:160:2: this_MetamodelDeclaration_0= ruleMetamodelDeclaration + { + + newCompositeNode(grammarAccess.getDeclarationAccess().getMetamodelDeclarationParserRuleCall()); + + pushFollow(FOLLOW_2); + this_MetamodelDeclaration_0=ruleMetamodelDeclaration(); + + state._fsp--; + + + current = this_MetamodelDeclaration_0; + afterParserOrEnumRuleCall(); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleDeclaration" + + + // $ANTLR start "entryRuleImport" + // InternalApplicationConfiguration.g:171:1: entryRuleImport returns [EObject current=null] : iv_ruleImport= ruleImport EOF ; + public final EObject entryRuleImport() throws RecognitionException { + EObject current = null; + + EObject iv_ruleImport = null; + + + try { + // InternalApplicationConfiguration.g:171:47: (iv_ruleImport= ruleImport EOF ) + // InternalApplicationConfiguration.g:172:2: iv_ruleImport= ruleImport EOF + { + newCompositeNode(grammarAccess.getImportRule()); + pushFollow(FOLLOW_1); + iv_ruleImport=ruleImport(); + + state._fsp--; + + current =iv_ruleImport; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleImport" + + + // $ANTLR start "ruleImport" + // InternalApplicationConfiguration.g:178:1: ruleImport returns [EObject current=null] : (this_EPackageImport_0= ruleEPackageImport | this_ViatraImport_1= ruleViatraImport ) ; + public final EObject ruleImport() throws RecognitionException { + EObject current = null; + + EObject this_EPackageImport_0 = null; + + EObject this_ViatraImport_1 = null; + + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:184:2: ( (this_EPackageImport_0= ruleEPackageImport | this_ViatraImport_1= ruleViatraImport ) ) + // InternalApplicationConfiguration.g:185:2: (this_EPackageImport_0= ruleEPackageImport | this_ViatraImport_1= ruleViatraImport ) + { + // InternalApplicationConfiguration.g:185:2: (this_EPackageImport_0= ruleEPackageImport | this_ViatraImport_1= ruleViatraImport ) + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0==11) ) { + int LA3_1 = input.LA(2); + + if ( (LA3_1==12) ) { + alt3=1; + } + else if ( (LA3_1==13) ) { + alt3=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + switch (alt3) { + case 1 : + // InternalApplicationConfiguration.g:186:3: this_EPackageImport_0= ruleEPackageImport + { + + newCompositeNode(grammarAccess.getImportAccess().getEPackageImportParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_EPackageImport_0=ruleEPackageImport(); + + state._fsp--; + + + current = this_EPackageImport_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalApplicationConfiguration.g:195:3: this_ViatraImport_1= ruleViatraImport + { + + newCompositeNode(grammarAccess.getImportAccess().getViatraImportParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_ViatraImport_1=ruleViatraImport(); + + state._fsp--; + + + current = this_ViatraImport_1; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleImport" + + + // $ANTLR start "entryRuleEPackageImport" + // InternalApplicationConfiguration.g:207:1: entryRuleEPackageImport returns [EObject current=null] : iv_ruleEPackageImport= ruleEPackageImport EOF ; + public final EObject entryRuleEPackageImport() throws RecognitionException { + EObject current = null; + + EObject iv_ruleEPackageImport = null; + + + try { + // InternalApplicationConfiguration.g:207:55: (iv_ruleEPackageImport= ruleEPackageImport EOF ) + // InternalApplicationConfiguration.g:208:2: iv_ruleEPackageImport= ruleEPackageImport EOF + { + newCompositeNode(grammarAccess.getEPackageImportRule()); + pushFollow(FOLLOW_1); + iv_ruleEPackageImport=ruleEPackageImport(); + + state._fsp--; + + current =iv_ruleEPackageImport; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleEPackageImport" + + + // $ANTLR start "ruleEPackageImport" + // InternalApplicationConfiguration.g:214:1: ruleEPackageImport returns [EObject current=null] : (otherlv_0= 'import' otherlv_1= 'epackage' ( (otherlv_2= RULE_STRING ) ) ) ; + public final EObject ruleEPackageImport() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_1=null; + Token otherlv_2=null; + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:220:2: ( (otherlv_0= 'import' otherlv_1= 'epackage' ( (otherlv_2= RULE_STRING ) ) ) ) + // InternalApplicationConfiguration.g:221:2: (otherlv_0= 'import' otherlv_1= 'epackage' ( (otherlv_2= RULE_STRING ) ) ) + { + // InternalApplicationConfiguration.g:221:2: (otherlv_0= 'import' otherlv_1= 'epackage' ( (otherlv_2= RULE_STRING ) ) ) + // InternalApplicationConfiguration.g:222:3: otherlv_0= 'import' otherlv_1= 'epackage' ( (otherlv_2= RULE_STRING ) ) + { + otherlv_0=(Token)match(input,11,FOLLOW_5); + + newLeafNode(otherlv_0, grammarAccess.getEPackageImportAccess().getImportKeyword_0()); + + otherlv_1=(Token)match(input,12,FOLLOW_6); + + newLeafNode(otherlv_1, grammarAccess.getEPackageImportAccess().getEpackageKeyword_1()); + + // InternalApplicationConfiguration.g:230:3: ( (otherlv_2= RULE_STRING ) ) + // InternalApplicationConfiguration.g:231:4: (otherlv_2= RULE_STRING ) + { + // InternalApplicationConfiguration.g:231:4: (otherlv_2= RULE_STRING ) + // InternalApplicationConfiguration.g:232:5: otherlv_2= RULE_STRING + { + + if (current==null) { + current = createModelElement(grammarAccess.getEPackageImportRule()); + } + + otherlv_2=(Token)match(input,RULE_STRING,FOLLOW_2); + + newLeafNode(otherlv_2, grammarAccess.getEPackageImportAccess().getImportedPackageEPackageCrossReference_2_0()); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleEPackageImport" + + + // $ANTLR start "entryRuleViatraImport" + // InternalApplicationConfiguration.g:247:1: entryRuleViatraImport returns [EObject current=null] : iv_ruleViatraImport= ruleViatraImport EOF ; + public final EObject entryRuleViatraImport() throws RecognitionException { + EObject current = null; + + EObject iv_ruleViatraImport = null; + + + try { + // InternalApplicationConfiguration.g:247:53: (iv_ruleViatraImport= ruleViatraImport EOF ) + // InternalApplicationConfiguration.g:248:2: iv_ruleViatraImport= ruleViatraImport EOF + { + newCompositeNode(grammarAccess.getViatraImportRule()); + pushFollow(FOLLOW_1); + iv_ruleViatraImport=ruleViatraImport(); + + state._fsp--; + + current =iv_ruleViatraImport; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleViatraImport" + + + // $ANTLR start "ruleViatraImport" + // InternalApplicationConfiguration.g:254:1: ruleViatraImport returns [EObject current=null] : (otherlv_0= 'import' otherlv_1= 'viatra' ( (otherlv_2= RULE_STRING ) ) ) ; + public final EObject ruleViatraImport() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_1=null; + Token otherlv_2=null; + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:260:2: ( (otherlv_0= 'import' otherlv_1= 'viatra' ( (otherlv_2= RULE_STRING ) ) ) ) + // InternalApplicationConfiguration.g:261:2: (otherlv_0= 'import' otherlv_1= 'viatra' ( (otherlv_2= RULE_STRING ) ) ) + { + // InternalApplicationConfiguration.g:261:2: (otherlv_0= 'import' otherlv_1= 'viatra' ( (otherlv_2= RULE_STRING ) ) ) + // InternalApplicationConfiguration.g:262:3: otherlv_0= 'import' otherlv_1= 'viatra' ( (otherlv_2= RULE_STRING ) ) + { + otherlv_0=(Token)match(input,11,FOLLOW_7); + + newLeafNode(otherlv_0, grammarAccess.getViatraImportAccess().getImportKeyword_0()); + + otherlv_1=(Token)match(input,13,FOLLOW_6); + + newLeafNode(otherlv_1, grammarAccess.getViatraImportAccess().getViatraKeyword_1()); + + // InternalApplicationConfiguration.g:270:3: ( (otherlv_2= RULE_STRING ) ) + // InternalApplicationConfiguration.g:271:4: (otherlv_2= RULE_STRING ) + { + // InternalApplicationConfiguration.g:271:4: (otherlv_2= RULE_STRING ) + // InternalApplicationConfiguration.g:272:5: otherlv_2= RULE_STRING + { + + if (current==null) { + current = createModelElement(grammarAccess.getViatraImportRule()); + } + + otherlv_2=(Token)match(input,RULE_STRING,FOLLOW_2); + + newLeafNode(otherlv_2, grammarAccess.getViatraImportAccess().getImportedViatraPatternModelCrossReference_2_0()); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleViatraImport" + + + // $ANTLR start "entryRuleMetamodelSpecification" + // InternalApplicationConfiguration.g:287:1: entryRuleMetamodelSpecification returns [EObject current=null] : iv_ruleMetamodelSpecification= ruleMetamodelSpecification EOF ; + public final EObject entryRuleMetamodelSpecification() throws RecognitionException { + EObject current = null; + + EObject iv_ruleMetamodelSpecification = null; + + + try { + // InternalApplicationConfiguration.g:287:63: (iv_ruleMetamodelSpecification= ruleMetamodelSpecification EOF ) + // InternalApplicationConfiguration.g:288:2: iv_ruleMetamodelSpecification= ruleMetamodelSpecification EOF + { + newCompositeNode(grammarAccess.getMetamodelSpecificationRule()); + pushFollow(FOLLOW_1); + iv_ruleMetamodelSpecification=ruleMetamodelSpecification(); + + state._fsp--; + + current =iv_ruleMetamodelSpecification; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleMetamodelSpecification" + + + // $ANTLR start "ruleMetamodelSpecification" + // InternalApplicationConfiguration.g:294:1: ruleMetamodelSpecification returns [EObject current=null] : (otherlv_0= '{' ( (lv_entries_1_0= ruleMetamodelEntry ) ) (otherlv_2= ',' ( (lv_entries_3_0= ruleMetamodelEntry ) ) )* otherlv_4= '}' ) ; + public final EObject ruleMetamodelSpecification() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token otherlv_4=null; + EObject lv_entries_1_0 = null; + + EObject lv_entries_3_0 = null; + + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:300:2: ( (otherlv_0= '{' ( (lv_entries_1_0= ruleMetamodelEntry ) ) (otherlv_2= ',' ( (lv_entries_3_0= ruleMetamodelEntry ) ) )* otherlv_4= '}' ) ) + // InternalApplicationConfiguration.g:301:2: (otherlv_0= '{' ( (lv_entries_1_0= ruleMetamodelEntry ) ) (otherlv_2= ',' ( (lv_entries_3_0= ruleMetamodelEntry ) ) )* otherlv_4= '}' ) + { + // InternalApplicationConfiguration.g:301:2: (otherlv_0= '{' ( (lv_entries_1_0= ruleMetamodelEntry ) ) (otherlv_2= ',' ( (lv_entries_3_0= ruleMetamodelEntry ) ) )* otherlv_4= '}' ) + // InternalApplicationConfiguration.g:302:3: otherlv_0= '{' ( (lv_entries_1_0= ruleMetamodelEntry ) ) (otherlv_2= ',' ( (lv_entries_3_0= ruleMetamodelEntry ) ) )* otherlv_4= '}' + { + otherlv_0=(Token)match(input,14,FOLLOW_8); + + newLeafNode(otherlv_0, grammarAccess.getMetamodelSpecificationAccess().getLeftCurlyBracketKeyword_0()); + + // InternalApplicationConfiguration.g:306:3: ( (lv_entries_1_0= ruleMetamodelEntry ) ) + // InternalApplicationConfiguration.g:307:4: (lv_entries_1_0= ruleMetamodelEntry ) + { + // InternalApplicationConfiguration.g:307:4: (lv_entries_1_0= ruleMetamodelEntry ) + // InternalApplicationConfiguration.g:308:5: lv_entries_1_0= ruleMetamodelEntry + { + + newCompositeNode(grammarAccess.getMetamodelSpecificationAccess().getEntriesMetamodelEntryParserRuleCall_1_0()); + + pushFollow(FOLLOW_9); + lv_entries_1_0=ruleMetamodelEntry(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getMetamodelSpecificationRule()); + } + add( + current, + "entries", + lv_entries_1_0, + "hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration.MetamodelEntry"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalApplicationConfiguration.g:325:3: (otherlv_2= ',' ( (lv_entries_3_0= ruleMetamodelEntry ) ) )* + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0==15) ) { + alt4=1; + } + + + switch (alt4) { + case 1 : + // InternalApplicationConfiguration.g:326:4: otherlv_2= ',' ( (lv_entries_3_0= ruleMetamodelEntry ) ) + { + otherlv_2=(Token)match(input,15,FOLLOW_8); + + newLeafNode(otherlv_2, grammarAccess.getMetamodelSpecificationAccess().getCommaKeyword_2_0()); + + // InternalApplicationConfiguration.g:330:4: ( (lv_entries_3_0= ruleMetamodelEntry ) ) + // InternalApplicationConfiguration.g:331:5: (lv_entries_3_0= ruleMetamodelEntry ) + { + // InternalApplicationConfiguration.g:331:5: (lv_entries_3_0= ruleMetamodelEntry ) + // InternalApplicationConfiguration.g:332:6: lv_entries_3_0= ruleMetamodelEntry + { + + newCompositeNode(grammarAccess.getMetamodelSpecificationAccess().getEntriesMetamodelEntryParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_9); + lv_entries_3_0=ruleMetamodelEntry(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getMetamodelSpecificationRule()); + } + add( + current, + "entries", + lv_entries_3_0, + "hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration.MetamodelEntry"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop4; + } + } while (true); + + otherlv_4=(Token)match(input,16,FOLLOW_2); + + newLeafNode(otherlv_4, grammarAccess.getMetamodelSpecificationAccess().getRightCurlyBracketKeyword_3()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMetamodelSpecification" + + + // $ANTLR start "entryRuleMetamodelEntry" + // InternalApplicationConfiguration.g:358:1: entryRuleMetamodelEntry returns [EObject current=null] : iv_ruleMetamodelEntry= ruleMetamodelEntry EOF ; + public final EObject entryRuleMetamodelEntry() throws RecognitionException { + EObject current = null; + + EObject iv_ruleMetamodelEntry = null; + + + try { + // InternalApplicationConfiguration.g:358:55: (iv_ruleMetamodelEntry= ruleMetamodelEntry EOF ) + // InternalApplicationConfiguration.g:359:2: iv_ruleMetamodelEntry= ruleMetamodelEntry EOF + { + newCompositeNode(grammarAccess.getMetamodelEntryRule()); + pushFollow(FOLLOW_1); + iv_ruleMetamodelEntry=ruleMetamodelEntry(); + + state._fsp--; + + current =iv_ruleMetamodelEntry; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleMetamodelEntry" + + + // $ANTLR start "ruleMetamodelEntry" + // InternalApplicationConfiguration.g:365:1: ruleMetamodelEntry returns [EObject current=null] : (this_MetamodelElement_0= ruleMetamodelElement | this_AllPackageEntry_1= ruleAllPackageEntry ) ; + public final EObject ruleMetamodelEntry() throws RecognitionException { + EObject current = null; + + EObject this_MetamodelElement_0 = null; + + EObject this_AllPackageEntry_1 = null; + + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:371:2: ( (this_MetamodelElement_0= ruleMetamodelElement | this_AllPackageEntry_1= ruleAllPackageEntry ) ) + // InternalApplicationConfiguration.g:372:2: (this_MetamodelElement_0= ruleMetamodelElement | this_AllPackageEntry_1= ruleAllPackageEntry ) + { + // InternalApplicationConfiguration.g:372:2: (this_MetamodelElement_0= ruleMetamodelElement | this_AllPackageEntry_1= ruleAllPackageEntry ) + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0==RULE_ID) ) { + alt5=1; + } + else if ( (LA5_0==17) ) { + alt5=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + + throw nvae; + } + switch (alt5) { + case 1 : + // InternalApplicationConfiguration.g:373:3: this_MetamodelElement_0= ruleMetamodelElement + { + + newCompositeNode(grammarAccess.getMetamodelEntryAccess().getMetamodelElementParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_MetamodelElement_0=ruleMetamodelElement(); + + state._fsp--; + + + current = this_MetamodelElement_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalApplicationConfiguration.g:382:3: this_AllPackageEntry_1= ruleAllPackageEntry + { + + newCompositeNode(grammarAccess.getMetamodelEntryAccess().getAllPackageEntryParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_AllPackageEntry_1=ruleAllPackageEntry(); + + state._fsp--; + + + current = this_AllPackageEntry_1; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMetamodelEntry" + + + // $ANTLR start "entryRuleAllPackageEntry" + // InternalApplicationConfiguration.g:394:1: entryRuleAllPackageEntry returns [EObject current=null] : iv_ruleAllPackageEntry= ruleAllPackageEntry EOF ; + public final EObject entryRuleAllPackageEntry() throws RecognitionException { + EObject current = null; + + EObject iv_ruleAllPackageEntry = null; + + + try { + // InternalApplicationConfiguration.g:394:56: (iv_ruleAllPackageEntry= ruleAllPackageEntry EOF ) + // InternalApplicationConfiguration.g:395:2: iv_ruleAllPackageEntry= ruleAllPackageEntry EOF + { + newCompositeNode(grammarAccess.getAllPackageEntryRule()); + pushFollow(FOLLOW_1); + iv_ruleAllPackageEntry=ruleAllPackageEntry(); + + state._fsp--; + + current =iv_ruleAllPackageEntry; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleAllPackageEntry" + + + // $ANTLR start "ruleAllPackageEntry" + // InternalApplicationConfiguration.g:401:1: ruleAllPackageEntry returns [EObject current=null] : (otherlv_0= 'package' ( (otherlv_1= RULE_ID ) ) (otherlv_2= 'excluding' otherlv_3= '{' ( (lv_exclusion_4_0= ruleMetamodelElement ) ) (otherlv_5= ',' ( (lv_exclusion_6_0= ruleMetamodelElement ) ) )* otherlv_7= '}' )? ) ; + public final EObject ruleAllPackageEntry() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + EObject lv_exclusion_4_0 = null; + + EObject lv_exclusion_6_0 = null; + + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:407:2: ( (otherlv_0= 'package' ( (otherlv_1= RULE_ID ) ) (otherlv_2= 'excluding' otherlv_3= '{' ( (lv_exclusion_4_0= ruleMetamodelElement ) ) (otherlv_5= ',' ( (lv_exclusion_6_0= ruleMetamodelElement ) ) )* otherlv_7= '}' )? ) ) + // InternalApplicationConfiguration.g:408:2: (otherlv_0= 'package' ( (otherlv_1= RULE_ID ) ) (otherlv_2= 'excluding' otherlv_3= '{' ( (lv_exclusion_4_0= ruleMetamodelElement ) ) (otherlv_5= ',' ( (lv_exclusion_6_0= ruleMetamodelElement ) ) )* otherlv_7= '}' )? ) + { + // InternalApplicationConfiguration.g:408:2: (otherlv_0= 'package' ( (otherlv_1= RULE_ID ) ) (otherlv_2= 'excluding' otherlv_3= '{' ( (lv_exclusion_4_0= ruleMetamodelElement ) ) (otherlv_5= ',' ( (lv_exclusion_6_0= ruleMetamodelElement ) ) )* otherlv_7= '}' )? ) + // InternalApplicationConfiguration.g:409:3: otherlv_0= 'package' ( (otherlv_1= RULE_ID ) ) (otherlv_2= 'excluding' otherlv_3= '{' ( (lv_exclusion_4_0= ruleMetamodelElement ) ) (otherlv_5= ',' ( (lv_exclusion_6_0= ruleMetamodelElement ) ) )* otherlv_7= '}' )? + { + otherlv_0=(Token)match(input,17,FOLLOW_10); + + newLeafNode(otherlv_0, grammarAccess.getAllPackageEntryAccess().getPackageKeyword_0()); + + // InternalApplicationConfiguration.g:413:3: ( (otherlv_1= RULE_ID ) ) + // InternalApplicationConfiguration.g:414:4: (otherlv_1= RULE_ID ) + { + // InternalApplicationConfiguration.g:414:4: (otherlv_1= RULE_ID ) + // InternalApplicationConfiguration.g:415:5: otherlv_1= RULE_ID + { + + if (current==null) { + current = createModelElement(grammarAccess.getAllPackageEntryRule()); + } + + otherlv_1=(Token)match(input,RULE_ID,FOLLOW_11); + + newLeafNode(otherlv_1, grammarAccess.getAllPackageEntryAccess().getPackageEPackageCrossReference_1_0()); + + + } + + + } + + // InternalApplicationConfiguration.g:426:3: (otherlv_2= 'excluding' otherlv_3= '{' ( (lv_exclusion_4_0= ruleMetamodelElement ) ) (otherlv_5= ',' ( (lv_exclusion_6_0= ruleMetamodelElement ) ) )* otherlv_7= '}' )? + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0==18) ) { + alt7=1; + } + switch (alt7) { + case 1 : + // InternalApplicationConfiguration.g:427:4: otherlv_2= 'excluding' otherlv_3= '{' ( (lv_exclusion_4_0= ruleMetamodelElement ) ) (otherlv_5= ',' ( (lv_exclusion_6_0= ruleMetamodelElement ) ) )* otherlv_7= '}' + { + otherlv_2=(Token)match(input,18,FOLLOW_12); + + newLeafNode(otherlv_2, grammarAccess.getAllPackageEntryAccess().getExcludingKeyword_2_0()); + + otherlv_3=(Token)match(input,14,FOLLOW_10); + + newLeafNode(otherlv_3, grammarAccess.getAllPackageEntryAccess().getLeftCurlyBracketKeyword_2_1()); + + // InternalApplicationConfiguration.g:435:4: ( (lv_exclusion_4_0= ruleMetamodelElement ) ) + // InternalApplicationConfiguration.g:436:5: (lv_exclusion_4_0= ruleMetamodelElement ) + { + // InternalApplicationConfiguration.g:436:5: (lv_exclusion_4_0= ruleMetamodelElement ) + // InternalApplicationConfiguration.g:437:6: lv_exclusion_4_0= ruleMetamodelElement + { + + newCompositeNode(grammarAccess.getAllPackageEntryAccess().getExclusionMetamodelElementParserRuleCall_2_2_0()); + + pushFollow(FOLLOW_9); + lv_exclusion_4_0=ruleMetamodelElement(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAllPackageEntryRule()); + } + add( + current, + "exclusion", + lv_exclusion_4_0, + "hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration.MetamodelElement"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalApplicationConfiguration.g:454:4: (otherlv_5= ',' ( (lv_exclusion_6_0= ruleMetamodelElement ) ) )* + loop6: + do { + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==15) ) { + alt6=1; + } + + + switch (alt6) { + case 1 : + // InternalApplicationConfiguration.g:455:5: otherlv_5= ',' ( (lv_exclusion_6_0= ruleMetamodelElement ) ) + { + otherlv_5=(Token)match(input,15,FOLLOW_10); + + newLeafNode(otherlv_5, grammarAccess.getAllPackageEntryAccess().getCommaKeyword_2_3_0()); + + // InternalApplicationConfiguration.g:459:5: ( (lv_exclusion_6_0= ruleMetamodelElement ) ) + // InternalApplicationConfiguration.g:460:6: (lv_exclusion_6_0= ruleMetamodelElement ) + { + // InternalApplicationConfiguration.g:460:6: (lv_exclusion_6_0= ruleMetamodelElement ) + // InternalApplicationConfiguration.g:461:7: lv_exclusion_6_0= ruleMetamodelElement + { + + newCompositeNode(grammarAccess.getAllPackageEntryAccess().getExclusionMetamodelElementParserRuleCall_2_3_1_0()); + + pushFollow(FOLLOW_9); + lv_exclusion_6_0=ruleMetamodelElement(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAllPackageEntryRule()); + } + add( + current, + "exclusion", + lv_exclusion_6_0, + "hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration.MetamodelElement"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop6; + } + } while (true); + + otherlv_7=(Token)match(input,16,FOLLOW_2); + + newLeafNode(otherlv_7, grammarAccess.getAllPackageEntryAccess().getRightCurlyBracketKeyword_2_4()); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleAllPackageEntry" + + + // $ANTLR start "entryRuleMetamodelElement" + // InternalApplicationConfiguration.g:488:1: entryRuleMetamodelElement returns [EObject current=null] : iv_ruleMetamodelElement= ruleMetamodelElement EOF ; + public final EObject entryRuleMetamodelElement() throws RecognitionException { + EObject current = null; + + EObject iv_ruleMetamodelElement = null; + + + try { + // InternalApplicationConfiguration.g:488:57: (iv_ruleMetamodelElement= ruleMetamodelElement EOF ) + // InternalApplicationConfiguration.g:489:2: iv_ruleMetamodelElement= ruleMetamodelElement EOF + { + newCompositeNode(grammarAccess.getMetamodelElementRule()); + pushFollow(FOLLOW_1); + iv_ruleMetamodelElement=ruleMetamodelElement(); + + state._fsp--; + + current =iv_ruleMetamodelElement; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleMetamodelElement" + + + // $ANTLR start "ruleMetamodelElement" + // InternalApplicationConfiguration.g:495:1: ruleMetamodelElement returns [EObject current=null] : ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '::' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= '.' ( (otherlv_4= RULE_ID ) ) )? ) ; + public final EObject ruleMetamodelElement() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_3=null; + Token otherlv_4=null; + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:501:2: ( ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '::' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= '.' ( (otherlv_4= RULE_ID ) ) )? ) ) + // InternalApplicationConfiguration.g:502:2: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '::' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= '.' ( (otherlv_4= RULE_ID ) ) )? ) + { + // InternalApplicationConfiguration.g:502:2: ( ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '::' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= '.' ( (otherlv_4= RULE_ID ) ) )? ) + // InternalApplicationConfiguration.g:503:3: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '::' )? ( (otherlv_2= RULE_ID ) ) (otherlv_3= '.' ( (otherlv_4= RULE_ID ) ) )? + { + // InternalApplicationConfiguration.g:503:3: ( ( (otherlv_0= RULE_ID ) ) otherlv_1= '::' )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0==RULE_ID) ) { + int LA8_1 = input.LA(2); + + if ( (LA8_1==19) ) { + alt8=1; + } + } + switch (alt8) { + case 1 : + // InternalApplicationConfiguration.g:504:4: ( (otherlv_0= RULE_ID ) ) otherlv_1= '::' + { + // InternalApplicationConfiguration.g:504:4: ( (otherlv_0= RULE_ID ) ) + // InternalApplicationConfiguration.g:505:5: (otherlv_0= RULE_ID ) + { + // InternalApplicationConfiguration.g:505:5: (otherlv_0= RULE_ID ) + // InternalApplicationConfiguration.g:506:6: otherlv_0= RULE_ID + { + + if (current==null) { + current = createModelElement(grammarAccess.getMetamodelElementRule()); + } + + otherlv_0=(Token)match(input,RULE_ID,FOLLOW_13); + + newLeafNode(otherlv_0, grammarAccess.getMetamodelElementAccess().getPackageEPackageCrossReference_0_0_0()); + + + } + + + } + + otherlv_1=(Token)match(input,19,FOLLOW_10); + + newLeafNode(otherlv_1, grammarAccess.getMetamodelElementAccess().getColonColonKeyword_0_1()); + + + } + break; + + } + + // InternalApplicationConfiguration.g:522:3: ( (otherlv_2= RULE_ID ) ) + // InternalApplicationConfiguration.g:523:4: (otherlv_2= RULE_ID ) + { + // InternalApplicationConfiguration.g:523:4: (otherlv_2= RULE_ID ) + // InternalApplicationConfiguration.g:524:5: otherlv_2= RULE_ID + { + + if (current==null) { + current = createModelElement(grammarAccess.getMetamodelElementRule()); + } + + otherlv_2=(Token)match(input,RULE_ID,FOLLOW_14); + + newLeafNode(otherlv_2, grammarAccess.getMetamodelElementAccess().getClassifierEClassifierCrossReference_1_0()); + + + } + + + } + + // InternalApplicationConfiguration.g:535:3: (otherlv_3= '.' ( (otherlv_4= RULE_ID ) ) )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0==20) ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalApplicationConfiguration.g:536:4: otherlv_3= '.' ( (otherlv_4= RULE_ID ) ) + { + otherlv_3=(Token)match(input,20,FOLLOW_10); + + newLeafNode(otherlv_3, grammarAccess.getMetamodelElementAccess().getFullStopKeyword_2_0()); + + // InternalApplicationConfiguration.g:540:4: ( (otherlv_4= RULE_ID ) ) + // InternalApplicationConfiguration.g:541:5: (otherlv_4= RULE_ID ) + { + // InternalApplicationConfiguration.g:541:5: (otherlv_4= RULE_ID ) + // InternalApplicationConfiguration.g:542:6: otherlv_4= RULE_ID + { + + if (current==null) { + current = createModelElement(grammarAccess.getMetamodelElementRule()); + } + + otherlv_4=(Token)match(input,RULE_ID,FOLLOW_2); + + newLeafNode(otherlv_4, grammarAccess.getMetamodelElementAccess().getFeatureENamedElementCrossReference_2_1_0()); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMetamodelElement" + + + // $ANTLR start "entryRuleMetamodelDeclaration" + // InternalApplicationConfiguration.g:558:1: entryRuleMetamodelDeclaration returns [EObject current=null] : iv_ruleMetamodelDeclaration= ruleMetamodelDeclaration EOF ; + public final EObject entryRuleMetamodelDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleMetamodelDeclaration = null; + + + try { + // InternalApplicationConfiguration.g:558:61: (iv_ruleMetamodelDeclaration= ruleMetamodelDeclaration EOF ) + // InternalApplicationConfiguration.g:559:2: iv_ruleMetamodelDeclaration= ruleMetamodelDeclaration EOF + { + newCompositeNode(grammarAccess.getMetamodelDeclarationRule()); + pushFollow(FOLLOW_1); + iv_ruleMetamodelDeclaration=ruleMetamodelDeclaration(); + + state._fsp--; + + current =iv_ruleMetamodelDeclaration; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleMetamodelDeclaration" + + + // $ANTLR start "ruleMetamodelDeclaration" + // InternalApplicationConfiguration.g:565:1: ruleMetamodelDeclaration returns [EObject current=null] : (otherlv_0= 'metamodel' ( (lv_name_1_0= RULE_ID ) ) ( (lv_specification_2_0= ruleMetamodelSpecification ) ) ) ; + public final EObject ruleMetamodelDeclaration() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token lv_name_1_0=null; + EObject lv_specification_2_0 = null; + + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:571:2: ( (otherlv_0= 'metamodel' ( (lv_name_1_0= RULE_ID ) ) ( (lv_specification_2_0= ruleMetamodelSpecification ) ) ) ) + // InternalApplicationConfiguration.g:572:2: (otherlv_0= 'metamodel' ( (lv_name_1_0= RULE_ID ) ) ( (lv_specification_2_0= ruleMetamodelSpecification ) ) ) + { + // InternalApplicationConfiguration.g:572:2: (otherlv_0= 'metamodel' ( (lv_name_1_0= RULE_ID ) ) ( (lv_specification_2_0= ruleMetamodelSpecification ) ) ) + // InternalApplicationConfiguration.g:573:3: otherlv_0= 'metamodel' ( (lv_name_1_0= RULE_ID ) ) ( (lv_specification_2_0= ruleMetamodelSpecification ) ) + { + otherlv_0=(Token)match(input,21,FOLLOW_10); + + newLeafNode(otherlv_0, grammarAccess.getMetamodelDeclarationAccess().getMetamodelKeyword_0()); + + // InternalApplicationConfiguration.g:577:3: ( (lv_name_1_0= RULE_ID ) ) + // InternalApplicationConfiguration.g:578:4: (lv_name_1_0= RULE_ID ) + { + // InternalApplicationConfiguration.g:578:4: (lv_name_1_0= RULE_ID ) + // InternalApplicationConfiguration.g:579:5: lv_name_1_0= RULE_ID + { + lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_12); + + newLeafNode(lv_name_1_0, grammarAccess.getMetamodelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getMetamodelDeclarationRule()); + } + setWithLastConsumed( + current, + "name", + lv_name_1_0, + "org.eclipse.xtext.common.Terminals.ID"); + + + } + + + } + + // InternalApplicationConfiguration.g:595:3: ( (lv_specification_2_0= ruleMetamodelSpecification ) ) + // InternalApplicationConfiguration.g:596:4: (lv_specification_2_0= ruleMetamodelSpecification ) + { + // InternalApplicationConfiguration.g:596:4: (lv_specification_2_0= ruleMetamodelSpecification ) + // InternalApplicationConfiguration.g:597:5: lv_specification_2_0= ruleMetamodelSpecification + { + + newCompositeNode(grammarAccess.getMetamodelDeclarationAccess().getSpecificationMetamodelSpecificationParserRuleCall_2_0()); + + pushFollow(FOLLOW_2); + lv_specification_2_0=ruleMetamodelSpecification(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getMetamodelDeclarationRule()); + } + set( + current, + "specification", + lv_specification_2_0, + "hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration.MetamodelSpecification"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMetamodelDeclaration" + + + // $ANTLR start "entryRuleMetamodelReference" + // InternalApplicationConfiguration.g:618:1: entryRuleMetamodelReference returns [EObject current=null] : iv_ruleMetamodelReference= ruleMetamodelReference EOF ; + public final EObject entryRuleMetamodelReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleMetamodelReference = null; + + + try { + // InternalApplicationConfiguration.g:618:59: (iv_ruleMetamodelReference= ruleMetamodelReference EOF ) + // InternalApplicationConfiguration.g:619:2: iv_ruleMetamodelReference= ruleMetamodelReference EOF + { + newCompositeNode(grammarAccess.getMetamodelReferenceRule()); + pushFollow(FOLLOW_1); + iv_ruleMetamodelReference=ruleMetamodelReference(); + + state._fsp--; + + current =iv_ruleMetamodelReference; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleMetamodelReference" + + + // $ANTLR start "ruleMetamodelReference" + // InternalApplicationConfiguration.g:625:1: ruleMetamodelReference returns [EObject current=null] : ( (otherlv_0= RULE_ID ) ) ; + public final EObject ruleMetamodelReference() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + + + enterRule(); + + try { + // InternalApplicationConfiguration.g:631:2: ( ( (otherlv_0= RULE_ID ) ) ) + // InternalApplicationConfiguration.g:632:2: ( (otherlv_0= RULE_ID ) ) + { + // InternalApplicationConfiguration.g:632:2: ( (otherlv_0= RULE_ID ) ) + // InternalApplicationConfiguration.g:633:3: (otherlv_0= RULE_ID ) + { + // InternalApplicationConfiguration.g:633:3: (otherlv_0= RULE_ID ) + // InternalApplicationConfiguration.g:634:4: otherlv_0= RULE_ID + { + + if (current==null) { + current = createModelElement(grammarAccess.getMetamodelReferenceRule()); + } + + otherlv_0=(Token)match(input,RULE_ID,FOLLOW_2); + + newLeafNode(otherlv_0, grammarAccess.getMetamodelReferenceAccess().getReferredMetamodelDeclarationCrossReference_0()); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMetamodelReference" + + // Delegated rules + + + + + 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[]{0x0000000000200802L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000200002L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000001000L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000002000L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000020020L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000018000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000020L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000040002L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000004000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000080000L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000100002L}); + +} \ No newline at end of file -- cgit v1.2.3-70-g09d2