[61] | 1 | /* |
---|
| 2 | * generated by Xtext |
---|
| 3 | */ |
---|
| 4 | package de.ugoe.cs.swe.bnftools.services; |
---|
| 5 | |
---|
| 6 | import com.google.inject.Singleton; |
---|
| 7 | import com.google.inject.Inject; |
---|
| 8 | |
---|
| 9 | import java.util.List; |
---|
| 10 | |
---|
| 11 | import org.eclipse.xtext.*; |
---|
| 12 | import org.eclipse.xtext.service.GrammarProvider; |
---|
| 13 | import org.eclipse.xtext.service.AbstractElementFinder.*; |
---|
| 14 | |
---|
| 15 | |
---|
| 16 | @Singleton |
---|
| 17 | public class EbnfGrammarAccess extends AbstractGrammarElementFinder { |
---|
| 18 | |
---|
| 19 | |
---|
| 20 | public class EtsiBnfElements extends AbstractParserRuleElementFinder { |
---|
| 21 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "EtsiBnf"); |
---|
| 22 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
---|
| 23 | private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0); |
---|
| 24 | private final Keyword cGrammarKeyword_0_0 = (Keyword)cGroup_0.eContents().get(0); |
---|
| 25 | private final Assignment cNameAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1); |
---|
| 26 | private final RuleCall cNameIDTerminalRuleCall_0_1_0 = (RuleCall)cNameAssignment_0_1.eContents().get(0); |
---|
| 27 | private final Group cGroup_0_2 = (Group)cGroup_0.eContents().get(2); |
---|
| 28 | private final Assignment cTypeAssignment_0_2_0 = (Assignment)cGroup_0_2.eContents().get(0); |
---|
| 29 | private final Keyword cTypeBnfKeyword_0_2_0_0 = (Keyword)cTypeAssignment_0_2_0.eContents().get(0); |
---|
| 30 | private final Keyword cSemicolonKeyword_0_2_1 = (Keyword)cGroup_0_2.eContents().get(1); |
---|
| 31 | private final Assignment cImportSectionAssignment_0_2_2 = (Assignment)cGroup_0_2.eContents().get(2); |
---|
| 32 | private final RuleCall cImportSectionImportSectionParserRuleCall_0_2_2_0 = (RuleCall)cImportSectionAssignment_0_2_2.eContents().get(0); |
---|
| 33 | private final Assignment cBnfEntryAssignment_0_2_3 = (Assignment)cGroup_0_2.eContents().get(3); |
---|
| 34 | private final RuleCall cBnfEntryBnfEntryParserRuleCall_0_2_3_0 = (RuleCall)cBnfEntryAssignment_0_2_3.eContents().get(0); |
---|
| 35 | private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); |
---|
| 36 | private final Assignment cTypeAssignment_1_0 = (Assignment)cGroup_1.eContents().get(0); |
---|
| 37 | private final Keyword cTypeDeltaKeyword_1_0_0 = (Keyword)cTypeAssignment_1_0.eContents().get(0); |
---|
| 38 | private final Keyword cSemicolonKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1); |
---|
| 39 | private final Assignment cImportSectionAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); |
---|
| 40 | private final RuleCall cImportSectionImportSectionParserRuleCall_1_2_0 = (RuleCall)cImportSectionAssignment_1_2.eContents().get(0); |
---|
| 41 | private final Assignment cDeltaEntryAssignment_1_3 = (Assignment)cGroup_1.eContents().get(3); |
---|
| 42 | private final RuleCall cDeltaEntryDeltaEntryParserRuleCall_1_3_0 = (RuleCall)cDeltaEntryAssignment_1_3.eContents().get(0); |
---|
| 43 | private final Group cGroup_2 = (Group)cAlternatives.eContents().get(2); |
---|
| 44 | private final Assignment cTypeAssignment_2_0 = (Assignment)cGroup_2.eContents().get(0); |
---|
| 45 | private final Keyword cTypeMergeKeyword_2_0_0 = (Keyword)cTypeAssignment_2_0.eContents().get(0); |
---|
| 46 | private final Keyword cSemicolonKeyword_2_1 = (Keyword)cGroup_2.eContents().get(1); |
---|
| 47 | private final Assignment cImportSectionAssignment_2_2 = (Assignment)cGroup_2.eContents().get(2); |
---|
| 48 | private final RuleCall cImportSectionImportSectionParserRuleCall_2_2_0 = (RuleCall)cImportSectionAssignment_2_2.eContents().get(0); |
---|
| 49 | private final Assignment cMergeEntryAssignment_2_3 = (Assignment)cGroup_2.eContents().get(3); |
---|
| 50 | private final RuleCall cMergeEntryMergeEntryParserRuleCall_2_3_0 = (RuleCall)cMergeEntryAssignment_2_3.eContents().get(0); |
---|
| 51 | |
---|
| 52 | //// -----------------------------------------------------------------------------------------------
|
---|
| 53 | //// Parser Rules
|
---|
| 54 | //// -----------------------------------------------------------------------------------------------
|
---|
[88] | 55 | //EtsiBnf: |
---|
| 56 | // "grammar" name=ID (type="/bnf"? ";" importSection=ImportSection? bnfEntry+=BnfEntry+) | type="/delta" ";" |
---|
| 57 | // importSection=ImportSection? deltaEntry+=DeltaEntry* | type="/merge" ";" importSection=ImportSection? |
---|
[61] | 58 | // mergeEntry+=MergeEntry*; |
---|
| 59 | public ParserRule getRule() { return rule; } |
---|
| 60 | |
---|
[88] | 61 | //"grammar" name=ID (type="/bnf"? ";" importSection=ImportSection? bnfEntry+=BnfEntry+) | type="/delta" ";" |
---|
| 62 | //importSection=ImportSection? deltaEntry+=DeltaEntry* | type="/merge" ";" importSection=ImportSection? |
---|
[61] | 63 | //mergeEntry+=MergeEntry* |
---|
| 64 | public Alternatives getAlternatives() { return cAlternatives; } |
---|
| 65 | |
---|
| 66 | //"grammar" name=ID (type="/bnf"? ";" importSection=ImportSection? bnfEntry+=BnfEntry+) |
---|
| 67 | public Group getGroup_0() { return cGroup_0; } |
---|
| 68 | |
---|
| 69 | //"grammar" |
---|
| 70 | public Keyword getGrammarKeyword_0_0() { return cGrammarKeyword_0_0; } |
---|
| 71 | |
---|
| 72 | //name=ID |
---|
| 73 | public Assignment getNameAssignment_0_1() { return cNameAssignment_0_1; } |
---|
| 74 | |
---|
| 75 | //ID |
---|
| 76 | public RuleCall getNameIDTerminalRuleCall_0_1_0() { return cNameIDTerminalRuleCall_0_1_0; } |
---|
| 77 | |
---|
| 78 | //type="/bnf"? ";" importSection=ImportSection? bnfEntry+=BnfEntry+ |
---|
| 79 | public Group getGroup_0_2() { return cGroup_0_2; } |
---|
| 80 | |
---|
| 81 | //type="/bnf"? |
---|
| 82 | public Assignment getTypeAssignment_0_2_0() { return cTypeAssignment_0_2_0; } |
---|
| 83 | |
---|
| 84 | //"/bnf" |
---|
| 85 | public Keyword getTypeBnfKeyword_0_2_0_0() { return cTypeBnfKeyword_0_2_0_0; } |
---|
| 86 | |
---|
| 87 | //";" |
---|
| 88 | public Keyword getSemicolonKeyword_0_2_1() { return cSemicolonKeyword_0_2_1; } |
---|
| 89 | |
---|
| 90 | //importSection=ImportSection? |
---|
| 91 | public Assignment getImportSectionAssignment_0_2_2() { return cImportSectionAssignment_0_2_2; } |
---|
| 92 | |
---|
| 93 | //ImportSection |
---|
| 94 | public RuleCall getImportSectionImportSectionParserRuleCall_0_2_2_0() { return cImportSectionImportSectionParserRuleCall_0_2_2_0; } |
---|
| 95 | |
---|
| 96 | //bnfEntry+=BnfEntry+ |
---|
| 97 | public Assignment getBnfEntryAssignment_0_2_3() { return cBnfEntryAssignment_0_2_3; } |
---|
| 98 | |
---|
| 99 | //BnfEntry |
---|
| 100 | public RuleCall getBnfEntryBnfEntryParserRuleCall_0_2_3_0() { return cBnfEntryBnfEntryParserRuleCall_0_2_3_0; } |
---|
| 101 | |
---|
| 102 | //type="/delta" ";" importSection=ImportSection? deltaEntry+=DeltaEntry* |
---|
| 103 | public Group getGroup_1() { return cGroup_1; } |
---|
| 104 | |
---|
| 105 | //type="/delta" |
---|
| 106 | public Assignment getTypeAssignment_1_0() { return cTypeAssignment_1_0; } |
---|
| 107 | |
---|
| 108 | //"/delta" |
---|
| 109 | public Keyword getTypeDeltaKeyword_1_0_0() { return cTypeDeltaKeyword_1_0_0; } |
---|
| 110 | |
---|
| 111 | //";" |
---|
| 112 | public Keyword getSemicolonKeyword_1_1() { return cSemicolonKeyword_1_1; } |
---|
| 113 | |
---|
| 114 | //importSection=ImportSection? |
---|
| 115 | public Assignment getImportSectionAssignment_1_2() { return cImportSectionAssignment_1_2; } |
---|
| 116 | |
---|
| 117 | //ImportSection |
---|
| 118 | public RuleCall getImportSectionImportSectionParserRuleCall_1_2_0() { return cImportSectionImportSectionParserRuleCall_1_2_0; } |
---|
| 119 | |
---|
| 120 | //deltaEntry+=DeltaEntry* |
---|
| 121 | public Assignment getDeltaEntryAssignment_1_3() { return cDeltaEntryAssignment_1_3; } |
---|
| 122 | |
---|
| 123 | //DeltaEntry |
---|
| 124 | public RuleCall getDeltaEntryDeltaEntryParserRuleCall_1_3_0() { return cDeltaEntryDeltaEntryParserRuleCall_1_3_0; } |
---|
| 125 | |
---|
| 126 | //type="/merge" ";" importSection=ImportSection? mergeEntry+=MergeEntry* |
---|
| 127 | public Group getGroup_2() { return cGroup_2; } |
---|
| 128 | |
---|
| 129 | //type="/merge" |
---|
| 130 | public Assignment getTypeAssignment_2_0() { return cTypeAssignment_2_0; } |
---|
| 131 | |
---|
| 132 | //"/merge" |
---|
| 133 | public Keyword getTypeMergeKeyword_2_0_0() { return cTypeMergeKeyword_2_0_0; } |
---|
| 134 | |
---|
| 135 | //";" |
---|
| 136 | public Keyword getSemicolonKeyword_2_1() { return cSemicolonKeyword_2_1; } |
---|
| 137 | |
---|
| 138 | //importSection=ImportSection? |
---|
| 139 | public Assignment getImportSectionAssignment_2_2() { return cImportSectionAssignment_2_2; } |
---|
| 140 | |
---|
| 141 | //ImportSection |
---|
| 142 | public RuleCall getImportSectionImportSectionParserRuleCall_2_2_0() { return cImportSectionImportSectionParserRuleCall_2_2_0; } |
---|
| 143 | |
---|
| 144 | //mergeEntry+=MergeEntry* |
---|
| 145 | public Assignment getMergeEntryAssignment_2_3() { return cMergeEntryAssignment_2_3; } |
---|
| 146 | |
---|
| 147 | //MergeEntry |
---|
| 148 | public RuleCall getMergeEntryMergeEntryParserRuleCall_2_3_0() { return cMergeEntryMergeEntryParserRuleCall_2_3_0; } |
---|
| 149 | } |
---|
| 150 | |
---|
| 151 | public class ImportSectionElements extends AbstractParserRuleElementFinder { |
---|
| 152 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ImportSection"); |
---|
| 153 | private final Assignment cImportsAssignment = (Assignment)rule.eContents().get(1); |
---|
| 154 | private final RuleCall cImportsImportParserRuleCall_0 = (RuleCall)cImportsAssignment.eContents().get(0); |
---|
| 155 | |
---|
[88] | 156 | //ImportSection: |
---|
[61] | 157 | // imports+=Import+; |
---|
| 158 | public ParserRule getRule() { return rule; } |
---|
| 159 | |
---|
| 160 | //imports+=Import+ |
---|
| 161 | public Assignment getImportsAssignment() { return cImportsAssignment; } |
---|
| 162 | |
---|
| 163 | //Import |
---|
| 164 | public RuleCall getImportsImportParserRuleCall_0() { return cImportsImportParserRuleCall_0; } |
---|
| 165 | } |
---|
| 166 | |
---|
| 167 | public class BnfEntryElements extends AbstractParserRuleElementFinder { |
---|
| 168 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "BnfEntry"); |
---|
| 169 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
---|
| 170 | private final Assignment cSectionheaderAssignment_0 = (Assignment)cAlternatives.eContents().get(0); |
---|
| 171 | private final RuleCall cSectionheaderSectionHeadingParserRuleCall_0_0 = (RuleCall)cSectionheaderAssignment_0.eContents().get(0); |
---|
| 172 | private final Assignment cRuleAssignment_1 = (Assignment)cAlternatives.eContents().get(1); |
---|
| 173 | private final RuleCall cRuleRuleParserRuleCall_1_0 = (RuleCall)cRuleAssignment_1.eContents().get(0); |
---|
[100] | 174 | private final Assignment cCommentAssignment_2 = (Assignment)cAlternatives.eContents().get(2); |
---|
| 175 | private final RuleCall cCommentCommentParserRuleCall_2_0 = (RuleCall)cCommentAssignment_2.eContents().get(0); |
---|
[61] | 176 | |
---|
[88] | 177 | //BnfEntry: |
---|
[100] | 178 | // sectionheader=SectionHeading | rule=Rule | comment=Comment; |
---|
[61] | 179 | public ParserRule getRule() { return rule; } |
---|
| 180 | |
---|
[100] | 181 | //sectionheader=SectionHeading | rule=Rule | comment=Comment |
---|
[61] | 182 | public Alternatives getAlternatives() { return cAlternatives; } |
---|
| 183 | |
---|
| 184 | //sectionheader=SectionHeading |
---|
| 185 | public Assignment getSectionheaderAssignment_0() { return cSectionheaderAssignment_0; } |
---|
| 186 | |
---|
| 187 | //SectionHeading |
---|
| 188 | public RuleCall getSectionheaderSectionHeadingParserRuleCall_0_0() { return cSectionheaderSectionHeadingParserRuleCall_0_0; } |
---|
| 189 | |
---|
| 190 | //rule=Rule |
---|
| 191 | public Assignment getRuleAssignment_1() { return cRuleAssignment_1; } |
---|
| 192 | |
---|
| 193 | //Rule |
---|
| 194 | public RuleCall getRuleRuleParserRuleCall_1_0() { return cRuleRuleParserRuleCall_1_0; } |
---|
[100] | 195 | |
---|
| 196 | //comment=Comment |
---|
| 197 | public Assignment getCommentAssignment_2() { return cCommentAssignment_2; } |
---|
| 198 | |
---|
| 199 | //Comment |
---|
| 200 | public RuleCall getCommentCommentParserRuleCall_2_0() { return cCommentCommentParserRuleCall_2_0; } |
---|
[61] | 201 | } |
---|
| 202 | |
---|
| 203 | public class DeltaEntryElements extends AbstractParserRuleElementFinder { |
---|
| 204 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "DeltaEntry"); |
---|
| 205 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
---|
| 206 | private final Assignment cRuleAssignment_0 = (Assignment)cAlternatives.eContents().get(0); |
---|
| 207 | private final RuleCall cRuleRuleParserRuleCall_0_0 = (RuleCall)cRuleAssignment_0.eContents().get(0); |
---|
| 208 | private final Assignment cSectionheaderAssignment_1 = (Assignment)cAlternatives.eContents().get(1); |
---|
| 209 | private final RuleCall cSectionheaderSectionHeadingParserRuleCall_1_0 = (RuleCall)cSectionheaderAssignment_1.eContents().get(0); |
---|
| 210 | private final Assignment cExtRuleAssignment_2 = (Assignment)cAlternatives.eContents().get(2); |
---|
| 211 | private final RuleCall cExtRuleExtRuleParserRuleCall_2_0 = (RuleCall)cExtRuleAssignment_2.eContents().get(0); |
---|
| 212 | |
---|
[88] | 213 | //DeltaEntry: |
---|
[61] | 214 | // rule=Rule | sectionheader=SectionHeading | extRule=ExtRule; |
---|
| 215 | public ParserRule getRule() { return rule; } |
---|
| 216 | |
---|
| 217 | //rule=Rule | sectionheader=SectionHeading | extRule=ExtRule |
---|
| 218 | public Alternatives getAlternatives() { return cAlternatives; } |
---|
| 219 | |
---|
| 220 | //rule=Rule |
---|
| 221 | public Assignment getRuleAssignment_0() { return cRuleAssignment_0; } |
---|
| 222 | |
---|
| 223 | //Rule |
---|
| 224 | public RuleCall getRuleRuleParserRuleCall_0_0() { return cRuleRuleParserRuleCall_0_0; } |
---|
| 225 | |
---|
| 226 | //sectionheader=SectionHeading |
---|
| 227 | public Assignment getSectionheaderAssignment_1() { return cSectionheaderAssignment_1; } |
---|
| 228 | |
---|
| 229 | //SectionHeading |
---|
| 230 | public RuleCall getSectionheaderSectionHeadingParserRuleCall_1_0() { return cSectionheaderSectionHeadingParserRuleCall_1_0; } |
---|
| 231 | |
---|
| 232 | //extRule=ExtRule |
---|
| 233 | public Assignment getExtRuleAssignment_2() { return cExtRuleAssignment_2; } |
---|
| 234 | |
---|
| 235 | //ExtRule |
---|
| 236 | public RuleCall getExtRuleExtRuleParserRuleCall_2_0() { return cExtRuleExtRuleParserRuleCall_2_0; } |
---|
| 237 | } |
---|
| 238 | |
---|
| 239 | public class MergeEntryElements extends AbstractParserRuleElementFinder { |
---|
| 240 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "MergeEntry"); |
---|
| 241 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
---|
| 242 | private final Assignment cSectionheaderAssignment_0 = (Assignment)cAlternatives.eContents().get(0); |
---|
| 243 | private final RuleCall cSectionheaderSectionHeadingParserRuleCall_0_0 = (RuleCall)cSectionheaderAssignment_0.eContents().get(0); |
---|
| 244 | private final Assignment cMergeRuleAssignment_1 = (Assignment)cAlternatives.eContents().get(1); |
---|
| 245 | private final RuleCall cMergeRuleMergeRuleParserRuleCall_1_0 = (RuleCall)cMergeRuleAssignment_1.eContents().get(0); |
---|
| 246 | |
---|
[88] | 247 | //MergeEntry: |
---|
[61] | 248 | // sectionheader=SectionHeading | mergeRule=MergeRule; |
---|
| 249 | public ParserRule getRule() { return rule; } |
---|
| 250 | |
---|
| 251 | //sectionheader=SectionHeading | mergeRule=MergeRule |
---|
| 252 | public Alternatives getAlternatives() { return cAlternatives; } |
---|
| 253 | |
---|
| 254 | //sectionheader=SectionHeading |
---|
| 255 | public Assignment getSectionheaderAssignment_0() { return cSectionheaderAssignment_0; } |
---|
| 256 | |
---|
| 257 | //SectionHeading |
---|
| 258 | public RuleCall getSectionheaderSectionHeadingParserRuleCall_0_0() { return cSectionheaderSectionHeadingParserRuleCall_0_0; } |
---|
| 259 | |
---|
| 260 | //mergeRule=MergeRule |
---|
| 261 | public Assignment getMergeRuleAssignment_1() { return cMergeRuleAssignment_1; } |
---|
| 262 | |
---|
| 263 | //MergeRule |
---|
| 264 | public RuleCall getMergeRuleMergeRuleParserRuleCall_1_0() { return cMergeRuleMergeRuleParserRuleCall_1_0; } |
---|
| 265 | } |
---|
| 266 | |
---|
| 267 | public class SectionHeadingElements extends AbstractParserRuleElementFinder { |
---|
| 268 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "SectionHeading"); |
---|
| 269 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 270 | private final Action cSectionHeadingAction_0 = (Action)cGroup.eContents().get(0); |
---|
| 271 | private final Assignment cSectionHeaderAssignment_1 = (Assignment)cGroup.eContents().get(1); |
---|
| 272 | private final RuleCall cSectionHeaderSECTIONHEADERTerminalRuleCall_1_0 = (RuleCall)cSectionHeaderAssignment_1.eContents().get(0); |
---|
| 273 | |
---|
[88] | 274 | //SectionHeading: |
---|
[61] | 275 | // {SectionHeading} sectionHeader=SECTIONHEADER; |
---|
| 276 | public ParserRule getRule() { return rule; } |
---|
| 277 | |
---|
| 278 | //{SectionHeading} sectionHeader=SECTIONHEADER |
---|
| 279 | public Group getGroup() { return cGroup; } |
---|
| 280 | |
---|
| 281 | //{SectionHeading} |
---|
| 282 | public Action getSectionHeadingAction_0() { return cSectionHeadingAction_0; } |
---|
| 283 | |
---|
| 284 | //sectionHeader=SECTIONHEADER |
---|
| 285 | public Assignment getSectionHeaderAssignment_1() { return cSectionHeaderAssignment_1; } |
---|
| 286 | |
---|
| 287 | //SECTIONHEADER |
---|
| 288 | public RuleCall getSectionHeaderSECTIONHEADERTerminalRuleCall_1_0() { return cSectionHeaderSECTIONHEADERTerminalRuleCall_1_0; } |
---|
| 289 | } |
---|
| 290 | |
---|
[100] | 291 | public class CommentElements extends AbstractParserRuleElementFinder { |
---|
| 292 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Comment"); |
---|
| 293 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 294 | private final Action cCommentAction_0 = (Action)cGroup.eContents().get(0); |
---|
| 295 | private final Assignment cContentAssignment_1 = (Assignment)cGroup.eContents().get(1); |
---|
| 296 | private final RuleCall cContentML_COMMENTTerminalRuleCall_1_0 = (RuleCall)cContentAssignment_1.eContents().get(0); |
---|
| 297 | |
---|
| 298 | //Comment: |
---|
| 299 | // {Comment} content=ML_COMMENT; |
---|
| 300 | public ParserRule getRule() { return rule; } |
---|
| 301 | |
---|
| 302 | //{Comment} content=ML_COMMENT |
---|
| 303 | public Group getGroup() { return cGroup; } |
---|
| 304 | |
---|
| 305 | //{Comment} |
---|
| 306 | public Action getCommentAction_0() { return cCommentAction_0; } |
---|
| 307 | |
---|
| 308 | //content=ML_COMMENT |
---|
| 309 | public Assignment getContentAssignment_1() { return cContentAssignment_1; } |
---|
| 310 | |
---|
| 311 | //ML_COMMENT |
---|
| 312 | public RuleCall getContentML_COMMENTTerminalRuleCall_1_0() { return cContentML_COMMENTTerminalRuleCall_1_0; } |
---|
| 313 | } |
---|
| 314 | |
---|
[61] | 315 | public class ImportElements extends AbstractParserRuleElementFinder { |
---|
| 316 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Import"); |
---|
| 317 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 318 | private final Keyword cImportKeyword_0 = (Keyword)cGroup.eContents().get(0); |
---|
| 319 | private final Assignment cImportURIAssignment_1 = (Assignment)cGroup.eContents().get(1); |
---|
| 320 | private final RuleCall cImportURISTRINGTerminalRuleCall_1_0 = (RuleCall)cImportURIAssignment_1.eContents().get(0); |
---|
| 321 | private final Group cGroup_2 = (Group)cGroup.eContents().get(2); |
---|
| 322 | private final Keyword cSolidusKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); |
---|
| 323 | private final Alternatives cAlternatives_2_1 = (Alternatives)cGroup_2.eContents().get(1); |
---|
| 324 | private final Assignment cGrammarTypeAssignment_2_1_0 = (Assignment)cAlternatives_2_1.eContents().get(0); |
---|
| 325 | private final Keyword cGrammarTypeCoreKeyword_2_1_0_0 = (Keyword)cGrammarTypeAssignment_2_1_0.eContents().get(0); |
---|
| 326 | private final Assignment cGrammarTypeAssignment_2_1_1 = (Assignment)cAlternatives_2_1.eContents().get(1); |
---|
| 327 | private final Keyword cGrammarTypePackageKeyword_2_1_1_0 = (Keyword)cGrammarTypeAssignment_2_1_1.eContents().get(0); |
---|
| 328 | private final Assignment cGrammarTypeAssignment_2_1_2 = (Assignment)cAlternatives_2_1.eContents().get(2); |
---|
| 329 | private final Keyword cGrammarTypeUpdateKeyword_2_1_2_0 = (Keyword)cGrammarTypeAssignment_2_1_2.eContents().get(0); |
---|
| 330 | private final Group cGroup_3 = (Group)cGroup.eContents().get(3); |
---|
| 331 | private final Keyword cLabelKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); |
---|
| 332 | private final Assignment cLabelAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); |
---|
| 333 | private final RuleCall cLabelIDTerminalRuleCall_3_1_0 = (RuleCall)cLabelAssignment_3_1.eContents().get(0); |
---|
| 334 | private final Keyword cSemicolonKeyword_4 = (Keyword)cGroup.eContents().get(4); |
---|
| 335 | |
---|
[88] | 336 | //Import: |
---|
| 337 | // "import" importURI=STRING ("/" (grammarType="core" | grammarType="package" | grammarType="update"))? ("label:" |
---|
[61] | 338 | // label=ID)? ";"; |
---|
| 339 | public ParserRule getRule() { return rule; } |
---|
| 340 | |
---|
[88] | 341 | //"import" importURI=STRING ("/" (grammarType="core" | grammarType="package" | grammarType="update"))? ("label:" |
---|
[61] | 342 | //label=ID)? ";" |
---|
| 343 | public Group getGroup() { return cGroup; } |
---|
| 344 | |
---|
| 345 | //"import" |
---|
| 346 | public Keyword getImportKeyword_0() { return cImportKeyword_0; } |
---|
| 347 | |
---|
| 348 | //importURI=STRING |
---|
| 349 | public Assignment getImportURIAssignment_1() { return cImportURIAssignment_1; } |
---|
| 350 | |
---|
| 351 | //STRING |
---|
| 352 | public RuleCall getImportURISTRINGTerminalRuleCall_1_0() { return cImportURISTRINGTerminalRuleCall_1_0; } |
---|
| 353 | |
---|
| 354 | //("/" (grammarType="core" | grammarType="package" | grammarType="update"))? |
---|
| 355 | public Group getGroup_2() { return cGroup_2; } |
---|
| 356 | |
---|
| 357 | //"/" |
---|
| 358 | public Keyword getSolidusKeyword_2_0() { return cSolidusKeyword_2_0; } |
---|
| 359 | |
---|
| 360 | //grammarType="core" | grammarType="package" | grammarType="update" |
---|
| 361 | public Alternatives getAlternatives_2_1() { return cAlternatives_2_1; } |
---|
| 362 | |
---|
| 363 | //grammarType="core" |
---|
| 364 | public Assignment getGrammarTypeAssignment_2_1_0() { return cGrammarTypeAssignment_2_1_0; } |
---|
| 365 | |
---|
| 366 | //"core" |
---|
| 367 | public Keyword getGrammarTypeCoreKeyword_2_1_0_0() { return cGrammarTypeCoreKeyword_2_1_0_0; } |
---|
| 368 | |
---|
| 369 | //grammarType="package" |
---|
| 370 | public Assignment getGrammarTypeAssignment_2_1_1() { return cGrammarTypeAssignment_2_1_1; } |
---|
| 371 | |
---|
| 372 | //"package" |
---|
| 373 | public Keyword getGrammarTypePackageKeyword_2_1_1_0() { return cGrammarTypePackageKeyword_2_1_1_0; } |
---|
| 374 | |
---|
| 375 | //grammarType="update" |
---|
| 376 | public Assignment getGrammarTypeAssignment_2_1_2() { return cGrammarTypeAssignment_2_1_2; } |
---|
| 377 | |
---|
| 378 | //"update" |
---|
| 379 | public Keyword getGrammarTypeUpdateKeyword_2_1_2_0() { return cGrammarTypeUpdateKeyword_2_1_2_0; } |
---|
| 380 | |
---|
| 381 | //("label:" label=ID)? |
---|
| 382 | public Group getGroup_3() { return cGroup_3; } |
---|
| 383 | |
---|
| 384 | //"label:" |
---|
| 385 | public Keyword getLabelKeyword_3_0() { return cLabelKeyword_3_0; } |
---|
| 386 | |
---|
| 387 | //label=ID |
---|
| 388 | public Assignment getLabelAssignment_3_1() { return cLabelAssignment_3_1; } |
---|
| 389 | |
---|
| 390 | //ID |
---|
| 391 | public RuleCall getLabelIDTerminalRuleCall_3_1_0() { return cLabelIDTerminalRuleCall_3_1_0; } |
---|
| 392 | |
---|
| 393 | //";" |
---|
| 394 | public Keyword getSemicolonKeyword_4() { return cSemicolonKeyword_4; } |
---|
| 395 | } |
---|
| 396 | |
---|
| 397 | public class RuleElements extends AbstractParserRuleElementFinder { |
---|
| 398 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Rule"); |
---|
| 399 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 400 | private final Group cGroup_0 = (Group)cGroup.eContents().get(0); |
---|
| 401 | private final Assignment cRulenumberAssignment_0_0 = (Assignment)cGroup_0.eContents().get(0); |
---|
| 402 | private final RuleCall cRulenumberINTTerminalRuleCall_0_0_0 = (RuleCall)cRulenumberAssignment_0_0.eContents().get(0); |
---|
| 403 | private final Assignment cRulevariantAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1); |
---|
| 404 | private final RuleCall cRulevariantIDTerminalRuleCall_0_1_0 = (RuleCall)cRulevariantAssignment_0_1.eContents().get(0); |
---|
| 405 | private final Keyword cFullStopKeyword_0_2 = (Keyword)cGroup_0.eContents().get(2); |
---|
| 406 | private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); |
---|
| 407 | private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); |
---|
| 408 | private final Keyword cColonColonEqualsSignKeyword_2 = (Keyword)cGroup.eContents().get(2); |
---|
| 409 | private final Assignment cDefinitionListAssignment_3 = (Assignment)cGroup.eContents().get(3); |
---|
| 410 | private final RuleCall cDefinitionListDefinitionListParserRuleCall_3_0 = (RuleCall)cDefinitionListAssignment_3.eContents().get(0); |
---|
| 411 | private final Keyword cSemicolonKeyword_4 = (Keyword)cGroup.eContents().get(4); |
---|
| 412 | |
---|
[65] | 413 | ////Import: 'import' importedNamespace=FqnWithWildCard;
|
---|
| 414 | ////FqnWithWildCard: Fqn('.*')? ';';
|
---|
| 415 | ////Fqn:ID('.'ID)*;
|
---|
[88] | 416 | //Rule: |
---|
[61] | 417 | // (rulenumber=INT rulevariant=ID? ".")? name=ID "::=" definitionList=DefinitionList? ";"?; |
---|
| 418 | public ParserRule getRule() { return rule; } |
---|
| 419 | |
---|
| 420 | //(rulenumber=INT rulevariant=ID? ".")? name=ID "::=" definitionList=DefinitionList? ";"? |
---|
| 421 | public Group getGroup() { return cGroup; } |
---|
| 422 | |
---|
| 423 | //(rulenumber=INT rulevariant=ID? ".")? |
---|
| 424 | public Group getGroup_0() { return cGroup_0; } |
---|
| 425 | |
---|
| 426 | //rulenumber=INT |
---|
| 427 | public Assignment getRulenumberAssignment_0_0() { return cRulenumberAssignment_0_0; } |
---|
| 428 | |
---|
| 429 | //INT |
---|
| 430 | public RuleCall getRulenumberINTTerminalRuleCall_0_0_0() { return cRulenumberINTTerminalRuleCall_0_0_0; } |
---|
| 431 | |
---|
| 432 | //rulevariant=ID? |
---|
| 433 | public Assignment getRulevariantAssignment_0_1() { return cRulevariantAssignment_0_1; } |
---|
| 434 | |
---|
| 435 | //ID |
---|
| 436 | public RuleCall getRulevariantIDTerminalRuleCall_0_1_0() { return cRulevariantIDTerminalRuleCall_0_1_0; } |
---|
| 437 | |
---|
| 438 | //"." |
---|
| 439 | public Keyword getFullStopKeyword_0_2() { return cFullStopKeyword_0_2; } |
---|
| 440 | |
---|
| 441 | //name=ID |
---|
| 442 | public Assignment getNameAssignment_1() { return cNameAssignment_1; } |
---|
| 443 | |
---|
| 444 | //ID |
---|
| 445 | public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; } |
---|
| 446 | |
---|
| 447 | //"::=" |
---|
| 448 | public Keyword getColonColonEqualsSignKeyword_2() { return cColonColonEqualsSignKeyword_2; } |
---|
| 449 | |
---|
| 450 | //definitionList=DefinitionList? |
---|
| 451 | public Assignment getDefinitionListAssignment_3() { return cDefinitionListAssignment_3; } |
---|
| 452 | |
---|
| 453 | //DefinitionList |
---|
| 454 | public RuleCall getDefinitionListDefinitionListParserRuleCall_3_0() { return cDefinitionListDefinitionListParserRuleCall_3_0; } |
---|
| 455 | |
---|
| 456 | //";"? |
---|
| 457 | public Keyword getSemicolonKeyword_4() { return cSemicolonKeyword_4; } |
---|
| 458 | } |
---|
| 459 | |
---|
| 460 | public class ExtRuleElements extends AbstractParserRuleElementFinder { |
---|
| 461 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ExtRule"); |
---|
| 462 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 463 | private final Group cGroup_0 = (Group)cGroup.eContents().get(0); |
---|
| 464 | private final Assignment cRulenumberAssignment_0_0 = (Assignment)cGroup_0.eContents().get(0); |
---|
| 465 | private final RuleCall cRulenumberINTTerminalRuleCall_0_0_0 = (RuleCall)cRulenumberAssignment_0_0.eContents().get(0); |
---|
| 466 | private final Assignment cRulevariantAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1); |
---|
| 467 | private final RuleCall cRulevariantIDTerminalRuleCall_0_1_0 = (RuleCall)cRulevariantAssignment_0_1.eContents().get(0); |
---|
| 468 | private final Keyword cFullStopKeyword_0_2 = (Keyword)cGroup_0.eContents().get(2); |
---|
| 469 | private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); |
---|
| 470 | private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); |
---|
| 471 | private final Group cGroup_2 = (Group)cGroup.eContents().get(2); |
---|
| 472 | private final Keyword cLeftParenthesisKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); |
---|
| 473 | private final Assignment cRuleextAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); |
---|
| 474 | private final RuleCall cRuleextINTTerminalRuleCall_2_1_0 = (RuleCall)cRuleextAssignment_2_1.eContents().get(0); |
---|
| 475 | private final Keyword cRightParenthesisKeyword_2_2 = (Keyword)cGroup_2.eContents().get(2); |
---|
| 476 | private final Keyword cLessThanSignHyphenMinusKeyword_3 = (Keyword)cGroup.eContents().get(3); |
---|
| 477 | private final Alternatives cAlternatives_4 = (Alternatives)cGroup.eContents().get(4); |
---|
| 478 | private final Assignment cElementsAssignment_4_0 = (Assignment)cAlternatives_4.eContents().get(0); |
---|
| 479 | private final RuleCall cElementsAtomParserRuleCall_4_0_0 = (RuleCall)cElementsAssignment_4_0.eContents().get(0); |
---|
| 480 | private final Keyword cRightParenthesisKeyword_4_1 = (Keyword)cAlternatives_4.eContents().get(1); |
---|
| 481 | private final Keyword cRightSquareBracketKeyword_4_2 = (Keyword)cAlternatives_4.eContents().get(2); |
---|
| 482 | private final Keyword cRightCurlyBracketKeyword_4_3 = (Keyword)cAlternatives_4.eContents().get(3); |
---|
| 483 | private final Keyword cVerticalLineKeyword_4_4 = (Keyword)cAlternatives_4.eContents().get(4); |
---|
| 484 | private final Keyword cLeftParenthesisKeyword_4_5 = (Keyword)cAlternatives_4.eContents().get(5); |
---|
| 485 | private final Keyword cLeftSquareBracketKeyword_4_6 = (Keyword)cAlternatives_4.eContents().get(6); |
---|
| 486 | private final Keyword cLeftCurlyBracketKeyword_4_7 = (Keyword)cAlternatives_4.eContents().get(7); |
---|
| 487 | private final Keyword cAsteriskKeyword_4_8 = (Keyword)cAlternatives_4.eContents().get(8); |
---|
| 488 | private final Keyword cPlusSignKeyword_4_9 = (Keyword)cAlternatives_4.eContents().get(9); |
---|
| 489 | private final Keyword cSemicolonKeyword_5 = (Keyword)cGroup.eContents().get(5); |
---|
| 490 | |
---|
[88] | 491 | //ExtRule: |
---|
| 492 | // (rulenumber=INT rulevariant=ID? ".")? name=ID ("(" ruleext=INT ")") "<-" (elements+=Atom | ")" | "]" | "}" | "|" | "(" |
---|
| 493 | // | "[" | "{" | "*" | "+")* ";"?; |
---|
[61] | 494 | public ParserRule getRule() { return rule; } |
---|
| 495 | |
---|
[88] | 496 | //(rulenumber=INT rulevariant=ID? ".")? name=ID ("(" ruleext=INT ")") "<-" (elements+=Atom | ")" | "]" | "}" | "|" | "(" | |
---|
[61] | 497 | //"[" | "{" | "*" | "+")* ";"? |
---|
| 498 | public Group getGroup() { return cGroup; } |
---|
| 499 | |
---|
| 500 | //(rulenumber=INT rulevariant=ID? ".")? |
---|
| 501 | public Group getGroup_0() { return cGroup_0; } |
---|
| 502 | |
---|
| 503 | //rulenumber=INT |
---|
| 504 | public Assignment getRulenumberAssignment_0_0() { return cRulenumberAssignment_0_0; } |
---|
| 505 | |
---|
| 506 | //INT |
---|
| 507 | public RuleCall getRulenumberINTTerminalRuleCall_0_0_0() { return cRulenumberINTTerminalRuleCall_0_0_0; } |
---|
| 508 | |
---|
| 509 | //rulevariant=ID? |
---|
| 510 | public Assignment getRulevariantAssignment_0_1() { return cRulevariantAssignment_0_1; } |
---|
| 511 | |
---|
| 512 | //ID |
---|
| 513 | public RuleCall getRulevariantIDTerminalRuleCall_0_1_0() { return cRulevariantIDTerminalRuleCall_0_1_0; } |
---|
| 514 | |
---|
| 515 | //"." |
---|
| 516 | public Keyword getFullStopKeyword_0_2() { return cFullStopKeyword_0_2; } |
---|
| 517 | |
---|
| 518 | //name=ID |
---|
| 519 | public Assignment getNameAssignment_1() { return cNameAssignment_1; } |
---|
| 520 | |
---|
| 521 | //ID |
---|
| 522 | public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; } |
---|
| 523 | |
---|
| 524 | //"(" ruleext=INT ")" |
---|
| 525 | public Group getGroup_2() { return cGroup_2; } |
---|
| 526 | |
---|
| 527 | //"(" |
---|
| 528 | public Keyword getLeftParenthesisKeyword_2_0() { return cLeftParenthesisKeyword_2_0; } |
---|
| 529 | |
---|
| 530 | //ruleext=INT |
---|
| 531 | public Assignment getRuleextAssignment_2_1() { return cRuleextAssignment_2_1; } |
---|
| 532 | |
---|
| 533 | //INT |
---|
| 534 | public RuleCall getRuleextINTTerminalRuleCall_2_1_0() { return cRuleextINTTerminalRuleCall_2_1_0; } |
---|
| 535 | |
---|
| 536 | //")" |
---|
| 537 | public Keyword getRightParenthesisKeyword_2_2() { return cRightParenthesisKeyword_2_2; } |
---|
| 538 | |
---|
| 539 | //"<-" |
---|
| 540 | public Keyword getLessThanSignHyphenMinusKeyword_3() { return cLessThanSignHyphenMinusKeyword_3; } |
---|
| 541 | |
---|
| 542 | //(elements+=Atom | ")" | "]" | "}" | "|" | "(" | "[" | "{" | "*" | "+")* |
---|
| 543 | public Alternatives getAlternatives_4() { return cAlternatives_4; } |
---|
| 544 | |
---|
| 545 | //elements+=Atom |
---|
| 546 | public Assignment getElementsAssignment_4_0() { return cElementsAssignment_4_0; } |
---|
| 547 | |
---|
| 548 | //Atom |
---|
| 549 | public RuleCall getElementsAtomParserRuleCall_4_0_0() { return cElementsAtomParserRuleCall_4_0_0; } |
---|
| 550 | |
---|
| 551 | //")" |
---|
| 552 | public Keyword getRightParenthesisKeyword_4_1() { return cRightParenthesisKeyword_4_1; } |
---|
| 553 | |
---|
| 554 | //"]" |
---|
| 555 | public Keyword getRightSquareBracketKeyword_4_2() { return cRightSquareBracketKeyword_4_2; } |
---|
| 556 | |
---|
| 557 | //"}" |
---|
| 558 | public Keyword getRightCurlyBracketKeyword_4_3() { return cRightCurlyBracketKeyword_4_3; } |
---|
| 559 | |
---|
| 560 | //"|" |
---|
| 561 | public Keyword getVerticalLineKeyword_4_4() { return cVerticalLineKeyword_4_4; } |
---|
| 562 | |
---|
| 563 | //"(" |
---|
| 564 | public Keyword getLeftParenthesisKeyword_4_5() { return cLeftParenthesisKeyword_4_5; } |
---|
| 565 | |
---|
| 566 | //"[" |
---|
| 567 | public Keyword getLeftSquareBracketKeyword_4_6() { return cLeftSquareBracketKeyword_4_6; } |
---|
| 568 | |
---|
| 569 | //"{" |
---|
| 570 | public Keyword getLeftCurlyBracketKeyword_4_7() { return cLeftCurlyBracketKeyword_4_7; } |
---|
| 571 | |
---|
| 572 | //"*" |
---|
| 573 | public Keyword getAsteriskKeyword_4_8() { return cAsteriskKeyword_4_8; } |
---|
| 574 | |
---|
| 575 | //"+" |
---|
| 576 | public Keyword getPlusSignKeyword_4_9() { return cPlusSignKeyword_4_9; } |
---|
| 577 | |
---|
| 578 | //";"? |
---|
| 579 | public Keyword getSemicolonKeyword_5() { return cSemicolonKeyword_5; } |
---|
| 580 | } |
---|
| 581 | |
---|
| 582 | public class MergeRuleElements extends AbstractParserRuleElementFinder { |
---|
| 583 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "MergeRule"); |
---|
| 584 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
---|
| 585 | private final RuleCall cGlobalCombinatorParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); |
---|
| 586 | private final RuleCall cRuleCombinatorParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); |
---|
| 587 | private final RuleCall cHookCombinatorParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); |
---|
| 588 | |
---|
[88] | 589 | //MergeRule: |
---|
[61] | 590 | // GlobalCombinator | RuleCombinator | HookCombinator; |
---|
| 591 | public ParserRule getRule() { return rule; } |
---|
| 592 | |
---|
| 593 | //GlobalCombinator | RuleCombinator | HookCombinator |
---|
| 594 | public Alternatives getAlternatives() { return cAlternatives; } |
---|
| 595 | |
---|
| 596 | //GlobalCombinator |
---|
| 597 | public RuleCall getGlobalCombinatorParserRuleCall_0() { return cGlobalCombinatorParserRuleCall_0; } |
---|
| 598 | |
---|
| 599 | //RuleCombinator |
---|
| 600 | public RuleCall getRuleCombinatorParserRuleCall_1() { return cRuleCombinatorParserRuleCall_1; } |
---|
| 601 | |
---|
| 602 | //HookCombinator |
---|
| 603 | public RuleCall getHookCombinatorParserRuleCall_2() { return cHookCombinatorParserRuleCall_2; } |
---|
| 604 | } |
---|
| 605 | |
---|
| 606 | public class GlobalCombinatorElements extends AbstractParserRuleElementFinder { |
---|
| 607 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "GlobalCombinator"); |
---|
| 608 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 609 | private final Group cGroup_0 = (Group)cGroup.eContents().get(0); |
---|
| 610 | private final Keyword cGlobalKeyword_0_0 = (Keyword)cGroup_0.eContents().get(0); |
---|
| 611 | private final Keyword cCombinatorKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1); |
---|
| 612 | private final Assignment cLogicAssignment_1 = (Assignment)cGroup.eContents().get(1); |
---|
| 613 | private final RuleCall cLogicLOGICTerminalRuleCall_1_0 = (RuleCall)cLogicAssignment_1.eContents().get(0); |
---|
| 614 | private final Keyword cSemicolonKeyword_2 = (Keyword)cGroup.eContents().get(2); |
---|
| 615 | |
---|
[88] | 616 | //GlobalCombinator: |
---|
[61] | 617 | // ("global" "combinator:") logic=LOGIC ";"?; |
---|
| 618 | public ParserRule getRule() { return rule; } |
---|
| 619 | |
---|
| 620 | //("global" "combinator:") logic=LOGIC ";"? |
---|
| 621 | public Group getGroup() { return cGroup; } |
---|
| 622 | |
---|
| 623 | //"global" "combinator:" |
---|
| 624 | public Group getGroup_0() { return cGroup_0; } |
---|
| 625 | |
---|
| 626 | //"global" |
---|
| 627 | public Keyword getGlobalKeyword_0_0() { return cGlobalKeyword_0_0; } |
---|
| 628 | |
---|
| 629 | //"combinator:" |
---|
| 630 | public Keyword getCombinatorKeyword_0_1() { return cCombinatorKeyword_0_1; } |
---|
| 631 | |
---|
| 632 | //logic=LOGIC |
---|
| 633 | public Assignment getLogicAssignment_1() { return cLogicAssignment_1; } |
---|
| 634 | |
---|
| 635 | //LOGIC |
---|
| 636 | public RuleCall getLogicLOGICTerminalRuleCall_1_0() { return cLogicLOGICTerminalRuleCall_1_0; } |
---|
| 637 | |
---|
| 638 | //";"? |
---|
| 639 | public Keyword getSemicolonKeyword_2() { return cSemicolonKeyword_2; } |
---|
| 640 | } |
---|
| 641 | |
---|
| 642 | public class RuleCombinatorElements extends AbstractParserRuleElementFinder { |
---|
| 643 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "RuleCombinator"); |
---|
| 644 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 645 | private final Group cGroup_0 = (Group)cGroup.eContents().get(0); |
---|
| 646 | private final Keyword cRuleKeyword_0_0 = (Keyword)cGroup_0.eContents().get(0); |
---|
| 647 | private final Keyword cCombinatorKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1); |
---|
| 648 | private final Assignment cNameAssignment_0_2 = (Assignment)cGroup_0.eContents().get(2); |
---|
| 649 | private final RuleCall cNameIDTerminalRuleCall_0_2_0 = (RuleCall)cNameAssignment_0_2.eContents().get(0); |
---|
| 650 | private final Assignment cLogicAssignment_1 = (Assignment)cGroup.eContents().get(1); |
---|
| 651 | private final RuleCall cLogicLOGICTerminalRuleCall_1_0 = (RuleCall)cLogicAssignment_1.eContents().get(0); |
---|
| 652 | private final Group cGroup_2 = (Group)cGroup.eContents().get(2); |
---|
| 653 | private final Keyword cLeftParenthesisKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); |
---|
| 654 | private final Assignment cLABELAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); |
---|
| 655 | private final RuleCall cLABELSTRINGTerminalRuleCall_2_1_0 = (RuleCall)cLABELAssignment_2_1.eContents().get(0); |
---|
| 656 | private final Keyword cRightParenthesisKeyword_2_2 = (Keyword)cGroup_2.eContents().get(2); |
---|
| 657 | private final Keyword cSemicolonKeyword_3 = (Keyword)cGroup.eContents().get(3); |
---|
| 658 | |
---|
[88] | 659 | //RuleCombinator: |
---|
[61] | 660 | // ("rule" "combinator:" name=ID) logic=LOGIC ("(" LABEL+=STRING ")")* ";"?; |
---|
| 661 | public ParserRule getRule() { return rule; } |
---|
| 662 | |
---|
| 663 | //("rule" "combinator:" name=ID) logic=LOGIC ("(" LABEL+=STRING ")")* ";"? |
---|
| 664 | public Group getGroup() { return cGroup; } |
---|
| 665 | |
---|
| 666 | //"rule" "combinator:" name=ID |
---|
| 667 | public Group getGroup_0() { return cGroup_0; } |
---|
| 668 | |
---|
| 669 | //"rule" |
---|
| 670 | public Keyword getRuleKeyword_0_0() { return cRuleKeyword_0_0; } |
---|
| 671 | |
---|
| 672 | //"combinator:" |
---|
| 673 | public Keyword getCombinatorKeyword_0_1() { return cCombinatorKeyword_0_1; } |
---|
| 674 | |
---|
| 675 | //name=ID |
---|
| 676 | public Assignment getNameAssignment_0_2() { return cNameAssignment_0_2; } |
---|
| 677 | |
---|
| 678 | //ID |
---|
| 679 | public RuleCall getNameIDTerminalRuleCall_0_2_0() { return cNameIDTerminalRuleCall_0_2_0; } |
---|
| 680 | |
---|
| 681 | //logic=LOGIC |
---|
| 682 | public Assignment getLogicAssignment_1() { return cLogicAssignment_1; } |
---|
| 683 | |
---|
| 684 | //LOGIC |
---|
| 685 | public RuleCall getLogicLOGICTerminalRuleCall_1_0() { return cLogicLOGICTerminalRuleCall_1_0; } |
---|
| 686 | |
---|
| 687 | //("(" LABEL+=STRING ")")* |
---|
| 688 | public Group getGroup_2() { return cGroup_2; } |
---|
| 689 | |
---|
| 690 | //"(" |
---|
| 691 | public Keyword getLeftParenthesisKeyword_2_0() { return cLeftParenthesisKeyword_2_0; } |
---|
| 692 | |
---|
| 693 | //LABEL+=STRING |
---|
| 694 | public Assignment getLABELAssignment_2_1() { return cLABELAssignment_2_1; } |
---|
| 695 | |
---|
| 696 | //STRING |
---|
| 697 | public RuleCall getLABELSTRINGTerminalRuleCall_2_1_0() { return cLABELSTRINGTerminalRuleCall_2_1_0; } |
---|
| 698 | |
---|
| 699 | //")" |
---|
| 700 | public Keyword getRightParenthesisKeyword_2_2() { return cRightParenthesisKeyword_2_2; } |
---|
| 701 | |
---|
| 702 | //";"? |
---|
| 703 | public Keyword getSemicolonKeyword_3() { return cSemicolonKeyword_3; } |
---|
| 704 | } |
---|
| 705 | |
---|
| 706 | public class HookCombinatorElements extends AbstractParserRuleElementFinder { |
---|
| 707 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "HookCombinator"); |
---|
| 708 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 709 | private final Keyword cHookKeyword_0 = (Keyword)cGroup.eContents().get(0); |
---|
| 710 | private final Keyword cCombinatorKeyword_1 = (Keyword)cGroup.eContents().get(1); |
---|
| 711 | private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); |
---|
| 712 | private final RuleCall cNameIDTerminalRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); |
---|
| 713 | private final Keyword cLeftParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3); |
---|
| 714 | private final Assignment cRuleextAssignment_4 = (Assignment)cGroup.eContents().get(4); |
---|
| 715 | private final RuleCall cRuleextINTTerminalRuleCall_4_0 = (RuleCall)cRuleextAssignment_4.eContents().get(0); |
---|
| 716 | private final Keyword cRightParenthesisKeyword_5 = (Keyword)cGroup.eContents().get(5); |
---|
| 717 | private final Assignment cLogicAssignment_6 = (Assignment)cGroup.eContents().get(6); |
---|
| 718 | private final RuleCall cLogicLOGICTerminalRuleCall_6_0 = (RuleCall)cLogicAssignment_6.eContents().get(0); |
---|
| 719 | private final Group cGroup_7 = (Group)cGroup.eContents().get(7); |
---|
| 720 | private final Keyword cLeftParenthesisKeyword_7_0 = (Keyword)cGroup_7.eContents().get(0); |
---|
| 721 | private final Assignment cLABELAssignment_7_1 = (Assignment)cGroup_7.eContents().get(1); |
---|
| 722 | private final RuleCall cLABELSTRINGTerminalRuleCall_7_1_0 = (RuleCall)cLABELAssignment_7_1.eContents().get(0); |
---|
| 723 | private final Keyword cRightParenthesisKeyword_7_2 = (Keyword)cGroup_7.eContents().get(2); |
---|
| 724 | private final Keyword cSemicolonKeyword_8 = (Keyword)cGroup.eContents().get(8); |
---|
| 725 | |
---|
[88] | 726 | //HookCombinator: |
---|
[61] | 727 | // "hook" "combinator:" name=ID "(" ruleext=INT ")" logic=LOGIC? ("(" LABEL+=STRING ")")+ ";"?; |
---|
| 728 | public ParserRule getRule() { return rule; } |
---|
| 729 | |
---|
| 730 | //"hook" "combinator:" name=ID "(" ruleext=INT ")" logic=LOGIC? ("(" LABEL+=STRING ")")+ ";"? |
---|
| 731 | public Group getGroup() { return cGroup; } |
---|
| 732 | |
---|
| 733 | //"hook" |
---|
| 734 | public Keyword getHookKeyword_0() { return cHookKeyword_0; } |
---|
| 735 | |
---|
| 736 | //"combinator:" |
---|
| 737 | public Keyword getCombinatorKeyword_1() { return cCombinatorKeyword_1; } |
---|
| 738 | |
---|
| 739 | //name=ID |
---|
| 740 | public Assignment getNameAssignment_2() { return cNameAssignment_2; } |
---|
| 741 | |
---|
| 742 | //ID |
---|
| 743 | public RuleCall getNameIDTerminalRuleCall_2_0() { return cNameIDTerminalRuleCall_2_0; } |
---|
| 744 | |
---|
| 745 | //"(" |
---|
| 746 | public Keyword getLeftParenthesisKeyword_3() { return cLeftParenthesisKeyword_3; } |
---|
| 747 | |
---|
| 748 | //ruleext=INT |
---|
| 749 | public Assignment getRuleextAssignment_4() { return cRuleextAssignment_4; } |
---|
| 750 | |
---|
| 751 | //INT |
---|
| 752 | public RuleCall getRuleextINTTerminalRuleCall_4_0() { return cRuleextINTTerminalRuleCall_4_0; } |
---|
| 753 | |
---|
| 754 | //")" |
---|
| 755 | public Keyword getRightParenthesisKeyword_5() { return cRightParenthesisKeyword_5; } |
---|
| 756 | |
---|
| 757 | //logic=LOGIC? |
---|
| 758 | public Assignment getLogicAssignment_6() { return cLogicAssignment_6; } |
---|
| 759 | |
---|
| 760 | //LOGIC |
---|
| 761 | public RuleCall getLogicLOGICTerminalRuleCall_6_0() { return cLogicLOGICTerminalRuleCall_6_0; } |
---|
| 762 | |
---|
| 763 | //("(" LABEL+=STRING ")")+ |
---|
| 764 | public Group getGroup_7() { return cGroup_7; } |
---|
| 765 | |
---|
| 766 | //"(" |
---|
| 767 | public Keyword getLeftParenthesisKeyword_7_0() { return cLeftParenthesisKeyword_7_0; } |
---|
| 768 | |
---|
| 769 | //LABEL+=STRING |
---|
| 770 | public Assignment getLABELAssignment_7_1() { return cLABELAssignment_7_1; } |
---|
| 771 | |
---|
| 772 | //STRING |
---|
| 773 | public RuleCall getLABELSTRINGTerminalRuleCall_7_1_0() { return cLABELSTRINGTerminalRuleCall_7_1_0; } |
---|
| 774 | |
---|
| 775 | //")" |
---|
| 776 | public Keyword getRightParenthesisKeyword_7_2() { return cRightParenthesisKeyword_7_2; } |
---|
| 777 | |
---|
| 778 | //";"? |
---|
| 779 | public Keyword getSemicolonKeyword_8() { return cSemicolonKeyword_8; } |
---|
| 780 | } |
---|
| 781 | |
---|
| 782 | public class DefinitionListElements extends AbstractParserRuleElementFinder { |
---|
| 783 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "DefinitionList"); |
---|
| 784 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 785 | private final Assignment cSingleDefinitionAssignment_0 = (Assignment)cGroup.eContents().get(0); |
---|
| 786 | private final RuleCall cSingleDefinitionSingleDefinitionParserRuleCall_0_0 = (RuleCall)cSingleDefinitionAssignment_0.eContents().get(0); |
---|
| 787 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); |
---|
| 788 | private final Keyword cVerticalLineKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); |
---|
| 789 | private final Assignment cSingleDefinitionAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); |
---|
| 790 | private final RuleCall cSingleDefinitionSingleDefinitionParserRuleCall_1_1_0 = (RuleCall)cSingleDefinitionAssignment_1_1.eContents().get(0); |
---|
| 791 | |
---|
[88] | 792 | //DefinitionList: |
---|
[61] | 793 | // singleDefinition+=SingleDefinition ("|" singleDefinition+=SingleDefinition)*; |
---|
| 794 | public ParserRule getRule() { return rule; } |
---|
| 795 | |
---|
| 796 | //singleDefinition+=SingleDefinition ("|" singleDefinition+=SingleDefinition)* |
---|
| 797 | public Group getGroup() { return cGroup; } |
---|
| 798 | |
---|
| 799 | //singleDefinition+=SingleDefinition |
---|
| 800 | public Assignment getSingleDefinitionAssignment_0() { return cSingleDefinitionAssignment_0; } |
---|
| 801 | |
---|
| 802 | //SingleDefinition |
---|
| 803 | public RuleCall getSingleDefinitionSingleDefinitionParserRuleCall_0_0() { return cSingleDefinitionSingleDefinitionParserRuleCall_0_0; } |
---|
| 804 | |
---|
| 805 | //("|" singleDefinition+=SingleDefinition)* |
---|
| 806 | public Group getGroup_1() { return cGroup_1; } |
---|
| 807 | |
---|
| 808 | //"|" |
---|
| 809 | public Keyword getVerticalLineKeyword_1_0() { return cVerticalLineKeyword_1_0; } |
---|
| 810 | |
---|
| 811 | //singleDefinition+=SingleDefinition |
---|
| 812 | public Assignment getSingleDefinitionAssignment_1_1() { return cSingleDefinitionAssignment_1_1; } |
---|
| 813 | |
---|
| 814 | //SingleDefinition |
---|
| 815 | public RuleCall getSingleDefinitionSingleDefinitionParserRuleCall_1_1_0() { return cSingleDefinitionSingleDefinitionParserRuleCall_1_1_0; } |
---|
| 816 | } |
---|
| 817 | |
---|
| 818 | public class SingleDefinitionElements extends AbstractParserRuleElementFinder { |
---|
| 819 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "SingleDefinition"); |
---|
| 820 | private final Assignment cTermsAssignment = (Assignment)rule.eContents().get(1); |
---|
| 821 | private final RuleCall cTermsTermParserRuleCall_0 = (RuleCall)cTermsAssignment.eContents().get(0); |
---|
| 822 | |
---|
[88] | 823 | //SingleDefinition: |
---|
[61] | 824 | // terms+=Term+; |
---|
| 825 | public ParserRule getRule() { return rule; } |
---|
| 826 | |
---|
| 827 | //terms+=Term+ |
---|
| 828 | public Assignment getTermsAssignment() { return cTermsAssignment; } |
---|
| 829 | |
---|
| 830 | //Term |
---|
| 831 | public RuleCall getTermsTermParserRuleCall_0() { return cTermsTermParserRuleCall_0; } |
---|
| 832 | } |
---|
| 833 | |
---|
| 834 | public class TermElements extends AbstractParserRuleElementFinder { |
---|
| 835 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Term"); |
---|
| 836 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
---|
| 837 | private final Assignment cTermAtomAssignment_0 = (Assignment)cAlternatives.eContents().get(0); |
---|
| 838 | private final RuleCall cTermAtomAtomParserRuleCall_0_0 = (RuleCall)cTermAtomAssignment_0.eContents().get(0); |
---|
| 839 | private final Assignment cTermGroupedSequenceAssignment_1 = (Assignment)cAlternatives.eContents().get(1); |
---|
| 840 | private final RuleCall cTermGroupedSequenceGroupedSequenceParserRuleCall_1_0 = (RuleCall)cTermGroupedSequenceAssignment_1.eContents().get(0); |
---|
| 841 | private final Assignment cTermOptionalSequenceAssignment_2 = (Assignment)cAlternatives.eContents().get(2); |
---|
| 842 | private final RuleCall cTermOptionalSequenceOptionalSequenceParserRuleCall_2_0 = (RuleCall)cTermOptionalSequenceAssignment_2.eContents().get(0); |
---|
| 843 | private final Assignment cTermRepeatedSequenceAssignment_3 = (Assignment)cAlternatives.eContents().get(3); |
---|
| 844 | private final RuleCall cTermRepeatedSequenceRepeatedSequenceParserRuleCall_3_0 = (RuleCall)cTermRepeatedSequenceAssignment_3.eContents().get(0); |
---|
| 845 | |
---|
[88] | 846 | //Term: |
---|
| 847 | // termAtom=Atom | termGroupedSequence=GroupedSequence | termOptionalSequence=OptionalSequence | |
---|
[61] | 848 | // termRepeatedSequence=RepeatedSequence; |
---|
| 849 | public ParserRule getRule() { return rule; } |
---|
| 850 | |
---|
[88] | 851 | //termAtom=Atom | termGroupedSequence=GroupedSequence | termOptionalSequence=OptionalSequence | |
---|
[61] | 852 | //termRepeatedSequence=RepeatedSequence |
---|
| 853 | public Alternatives getAlternatives() { return cAlternatives; } |
---|
| 854 | |
---|
| 855 | //termAtom=Atom |
---|
| 856 | public Assignment getTermAtomAssignment_0() { return cTermAtomAssignment_0; } |
---|
| 857 | |
---|
| 858 | //Atom |
---|
| 859 | public RuleCall getTermAtomAtomParserRuleCall_0_0() { return cTermAtomAtomParserRuleCall_0_0; } |
---|
| 860 | |
---|
| 861 | //termGroupedSequence=GroupedSequence |
---|
| 862 | public Assignment getTermGroupedSequenceAssignment_1() { return cTermGroupedSequenceAssignment_1; } |
---|
| 863 | |
---|
| 864 | //GroupedSequence |
---|
| 865 | public RuleCall getTermGroupedSequenceGroupedSequenceParserRuleCall_1_0() { return cTermGroupedSequenceGroupedSequenceParserRuleCall_1_0; } |
---|
| 866 | |
---|
| 867 | //termOptionalSequence=OptionalSequence |
---|
| 868 | public Assignment getTermOptionalSequenceAssignment_2() { return cTermOptionalSequenceAssignment_2; } |
---|
| 869 | |
---|
| 870 | //OptionalSequence |
---|
| 871 | public RuleCall getTermOptionalSequenceOptionalSequenceParserRuleCall_2_0() { return cTermOptionalSequenceOptionalSequenceParserRuleCall_2_0; } |
---|
| 872 | |
---|
| 873 | //termRepeatedSequence=RepeatedSequence |
---|
| 874 | public Assignment getTermRepeatedSequenceAssignment_3() { return cTermRepeatedSequenceAssignment_3; } |
---|
| 875 | |
---|
| 876 | //RepeatedSequence |
---|
| 877 | public RuleCall getTermRepeatedSequenceRepeatedSequenceParserRuleCall_3_0() { return cTermRepeatedSequenceRepeatedSequenceParserRuleCall_3_0; } |
---|
| 878 | } |
---|
| 879 | |
---|
| 880 | public class AtomElements extends AbstractParserRuleElementFinder { |
---|
| 881 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Atom"); |
---|
| 882 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
---|
| 883 | private final Assignment cAtomStringRuleAssignment_0 = (Assignment)cAlternatives.eContents().get(0); |
---|
| 884 | private final RuleCall cAtomStringRuleStringRuleParserRuleCall_0_0 = (RuleCall)cAtomStringRuleAssignment_0.eContents().get(0); |
---|
| 885 | private final Assignment cAtomRuleReferenceAssignment_1 = (Assignment)cAlternatives.eContents().get(1); |
---|
| 886 | private final RuleCall cAtomRuleReferenceRuleReferenceParserRuleCall_1_0 = (RuleCall)cAtomRuleReferenceAssignment_1.eContents().get(0); |
---|
| 887 | |
---|
[88] | 888 | //Atom: |
---|
[61] | 889 | // atomStringRule=StringRule | atomRuleReference=RuleReference; |
---|
| 890 | public ParserRule getRule() { return rule; } |
---|
| 891 | |
---|
| 892 | //atomStringRule=StringRule | atomRuleReference=RuleReference |
---|
| 893 | public Alternatives getAlternatives() { return cAlternatives; } |
---|
| 894 | |
---|
| 895 | //atomStringRule=StringRule |
---|
| 896 | public Assignment getAtomStringRuleAssignment_0() { return cAtomStringRuleAssignment_0; } |
---|
| 897 | |
---|
| 898 | //StringRule |
---|
| 899 | public RuleCall getAtomStringRuleStringRuleParserRuleCall_0_0() { return cAtomStringRuleStringRuleParserRuleCall_0_0; } |
---|
| 900 | |
---|
| 901 | //atomRuleReference=RuleReference |
---|
| 902 | public Assignment getAtomRuleReferenceAssignment_1() { return cAtomRuleReferenceAssignment_1; } |
---|
| 903 | |
---|
| 904 | //RuleReference |
---|
| 905 | public RuleCall getAtomRuleReferenceRuleReferenceParserRuleCall_1_0() { return cAtomRuleReferenceRuleReferenceParserRuleCall_1_0; } |
---|
| 906 | } |
---|
| 907 | |
---|
| 908 | public class RuleReferenceElements extends AbstractParserRuleElementFinder { |
---|
| 909 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "RuleReference"); |
---|
| 910 | private final Assignment cRulerefAssignment = (Assignment)rule.eContents().get(1); |
---|
| 911 | private final CrossReference cRulerefRuleCrossReference_0 = (CrossReference)cRulerefAssignment.eContents().get(0); |
---|
| 912 | private final RuleCall cRulerefRuleIDTerminalRuleCall_0_1 = (RuleCall)cRulerefRuleCrossReference_0.eContents().get(1); |
---|
| 913 | |
---|
[88] | 914 | //RuleReference: |
---|
[61] | 915 | // ruleref=[Rule]; |
---|
| 916 | public ParserRule getRule() { return rule; } |
---|
| 917 | |
---|
| 918 | //ruleref=[Rule] |
---|
| 919 | public Assignment getRulerefAssignment() { return cRulerefAssignment; } |
---|
| 920 | |
---|
| 921 | //[Rule] |
---|
| 922 | public CrossReference getRulerefRuleCrossReference_0() { return cRulerefRuleCrossReference_0; } |
---|
| 923 | |
---|
| 924 | //ID |
---|
| 925 | public RuleCall getRulerefRuleIDTerminalRuleCall_0_1() { return cRulerefRuleIDTerminalRuleCall_0_1; } |
---|
| 926 | } |
---|
| 927 | |
---|
| 928 | public class StringRuleElements extends AbstractParserRuleElementFinder { |
---|
| 929 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "StringRule"); |
---|
| 930 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); |
---|
| 931 | private final Assignment cLiteralAssignment_0 = (Assignment)cAlternatives.eContents().get(0); |
---|
| 932 | private final RuleCall cLiteralSTRINGTerminalRuleCall_0_0 = (RuleCall)cLiteralAssignment_0.eContents().get(0); |
---|
| 933 | private final Assignment cColonAssignment_1 = (Assignment)cAlternatives.eContents().get(1); |
---|
| 934 | private final RuleCall cColonCOLONTerminalRuleCall_1_0 = (RuleCall)cColonAssignment_1.eContents().get(0); |
---|
| 935 | |
---|
[88] | 936 | //StringRule: |
---|
[61] | 937 | // literal=STRING | colon=COLON; |
---|
| 938 | public ParserRule getRule() { return rule; } |
---|
| 939 | |
---|
| 940 | //literal=STRING | colon=COLON |
---|
| 941 | public Alternatives getAlternatives() { return cAlternatives; } |
---|
| 942 | |
---|
| 943 | //literal=STRING |
---|
| 944 | public Assignment getLiteralAssignment_0() { return cLiteralAssignment_0; } |
---|
| 945 | |
---|
| 946 | //STRING |
---|
| 947 | public RuleCall getLiteralSTRINGTerminalRuleCall_0_0() { return cLiteralSTRINGTerminalRuleCall_0_0; } |
---|
| 948 | |
---|
| 949 | //colon=COLON |
---|
| 950 | public Assignment getColonAssignment_1() { return cColonAssignment_1; } |
---|
| 951 | |
---|
| 952 | //COLON |
---|
| 953 | public RuleCall getColonCOLONTerminalRuleCall_1_0() { return cColonCOLONTerminalRuleCall_1_0; } |
---|
| 954 | } |
---|
| 955 | |
---|
| 956 | public class GroupedSequenceElements extends AbstractParserRuleElementFinder { |
---|
| 957 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "GroupedSequence"); |
---|
| 958 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 959 | private final Keyword cLeftParenthesisKeyword_0 = (Keyword)cGroup.eContents().get(0); |
---|
| 960 | private final Assignment cDefinitionListAssignment_1 = (Assignment)cGroup.eContents().get(1); |
---|
| 961 | private final RuleCall cDefinitionListDefinitionListParserRuleCall_1_0 = (RuleCall)cDefinitionListAssignment_1.eContents().get(0); |
---|
| 962 | private final Keyword cRightParenthesisKeyword_2 = (Keyword)cGroup.eContents().get(2); |
---|
| 963 | |
---|
[88] | 964 | //GroupedSequence: |
---|
[61] | 965 | // "(" definitionList+=DefinitionList ")"; |
---|
| 966 | public ParserRule getRule() { return rule; } |
---|
| 967 | |
---|
| 968 | //"(" definitionList+=DefinitionList ")" |
---|
| 969 | public Group getGroup() { return cGroup; } |
---|
| 970 | |
---|
| 971 | //"(" |
---|
| 972 | public Keyword getLeftParenthesisKeyword_0() { return cLeftParenthesisKeyword_0; } |
---|
| 973 | |
---|
| 974 | //definitionList+=DefinitionList |
---|
| 975 | public Assignment getDefinitionListAssignment_1() { return cDefinitionListAssignment_1; } |
---|
| 976 | |
---|
| 977 | //DefinitionList |
---|
| 978 | public RuleCall getDefinitionListDefinitionListParserRuleCall_1_0() { return cDefinitionListDefinitionListParserRuleCall_1_0; } |
---|
| 979 | |
---|
| 980 | //")" |
---|
| 981 | public Keyword getRightParenthesisKeyword_2() { return cRightParenthesisKeyword_2; } |
---|
| 982 | } |
---|
| 983 | |
---|
| 984 | public class OptionalSequenceElements extends AbstractParserRuleElementFinder { |
---|
| 985 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "OptionalSequence"); |
---|
| 986 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 987 | private final Keyword cLeftSquareBracketKeyword_0 = (Keyword)cGroup.eContents().get(0); |
---|
| 988 | private final Assignment cDefinitionListAssignment_1 = (Assignment)cGroup.eContents().get(1); |
---|
| 989 | private final RuleCall cDefinitionListDefinitionListParserRuleCall_1_0 = (RuleCall)cDefinitionListAssignment_1.eContents().get(0); |
---|
| 990 | private final Keyword cRightSquareBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); |
---|
| 991 | |
---|
[88] | 992 | //OptionalSequence: |
---|
[61] | 993 | // "[" definitionList+=DefinitionList "]"; |
---|
| 994 | public ParserRule getRule() { return rule; } |
---|
| 995 | |
---|
| 996 | //"[" definitionList+=DefinitionList "]" |
---|
| 997 | public Group getGroup() { return cGroup; } |
---|
| 998 | |
---|
| 999 | //"[" |
---|
| 1000 | public Keyword getLeftSquareBracketKeyword_0() { return cLeftSquareBracketKeyword_0; } |
---|
| 1001 | |
---|
| 1002 | //definitionList+=DefinitionList |
---|
| 1003 | public Assignment getDefinitionListAssignment_1() { return cDefinitionListAssignment_1; } |
---|
| 1004 | |
---|
| 1005 | //DefinitionList |
---|
| 1006 | public RuleCall getDefinitionListDefinitionListParserRuleCall_1_0() { return cDefinitionListDefinitionListParserRuleCall_1_0; } |
---|
| 1007 | |
---|
| 1008 | //"]" |
---|
| 1009 | public Keyword getRightSquareBracketKeyword_2() { return cRightSquareBracketKeyword_2; } |
---|
| 1010 | } |
---|
| 1011 | |
---|
| 1012 | public class RepeatedSequenceElements extends AbstractParserRuleElementFinder { |
---|
| 1013 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "RepeatedSequence"); |
---|
| 1014 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 1015 | private final Keyword cLeftCurlyBracketKeyword_0 = (Keyword)cGroup.eContents().get(0); |
---|
| 1016 | private final Assignment cDefinitionsAssignment_1 = (Assignment)cGroup.eContents().get(1); |
---|
| 1017 | private final RuleCall cDefinitionsDefinitionListParserRuleCall_1_0 = (RuleCall)cDefinitionsAssignment_1.eContents().get(0); |
---|
| 1018 | private final Keyword cRightCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); |
---|
[95] | 1019 | private final Alternatives cAlternatives_3 = (Alternatives)cGroup.eContents().get(3); |
---|
| 1020 | private final Assignment cMorethanonceAssignment_3_0 = (Assignment)cAlternatives_3.eContents().get(0); |
---|
| 1021 | private final Keyword cMorethanoncePlusSignKeyword_3_0_0 = (Keyword)cMorethanonceAssignment_3_0.eContents().get(0); |
---|
| 1022 | private final Assignment cRangeAssignment_3_1 = (Assignment)cAlternatives_3.eContents().get(1); |
---|
| 1023 | private final RuleCall cRangeRepeatRangeParserRuleCall_3_1_0 = (RuleCall)cRangeAssignment_3_1.eContents().get(0); |
---|
[61] | 1024 | |
---|
[88] | 1025 | //RepeatedSequence: |
---|
[95] | 1026 | // "{" definitions+=DefinitionList "}" (morethanonce?="+"? | range=RepeatRange?); |
---|
[61] | 1027 | public ParserRule getRule() { return rule; } |
---|
| 1028 | |
---|
[95] | 1029 | //"{" definitions+=DefinitionList "}" (morethanonce?="+"? | range=RepeatRange?) |
---|
[61] | 1030 | public Group getGroup() { return cGroup; } |
---|
| 1031 | |
---|
| 1032 | //"{" |
---|
| 1033 | public Keyword getLeftCurlyBracketKeyword_0() { return cLeftCurlyBracketKeyword_0; } |
---|
| 1034 | |
---|
| 1035 | //definitions+=DefinitionList |
---|
| 1036 | public Assignment getDefinitionsAssignment_1() { return cDefinitionsAssignment_1; } |
---|
| 1037 | |
---|
| 1038 | //DefinitionList |
---|
| 1039 | public RuleCall getDefinitionsDefinitionListParserRuleCall_1_0() { return cDefinitionsDefinitionListParserRuleCall_1_0; } |
---|
| 1040 | |
---|
| 1041 | //"}" |
---|
| 1042 | public Keyword getRightCurlyBracketKeyword_2() { return cRightCurlyBracketKeyword_2; } |
---|
| 1043 | |
---|
[95] | 1044 | //morethanonce?="+"? | range=RepeatRange? |
---|
| 1045 | public Alternatives getAlternatives_3() { return cAlternatives_3; } |
---|
| 1046 | |
---|
[61] | 1047 | //morethanonce?="+"? |
---|
[95] | 1048 | public Assignment getMorethanonceAssignment_3_0() { return cMorethanonceAssignment_3_0; } |
---|
[61] | 1049 | |
---|
| 1050 | //"+" |
---|
[95] | 1051 | public Keyword getMorethanoncePlusSignKeyword_3_0_0() { return cMorethanoncePlusSignKeyword_3_0_0; } |
---|
| 1052 | |
---|
| 1053 | //range=RepeatRange? |
---|
| 1054 | public Assignment getRangeAssignment_3_1() { return cRangeAssignment_3_1; } |
---|
| 1055 | |
---|
| 1056 | //RepeatRange |
---|
| 1057 | public RuleCall getRangeRepeatRangeParserRuleCall_3_1_0() { return cRangeRepeatRangeParserRuleCall_3_1_0; } |
---|
[61] | 1058 | } |
---|
[95] | 1059 | |
---|
| 1060 | public class RepeatRangeElements extends AbstractParserRuleElementFinder { |
---|
| 1061 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "RepeatRange"); |
---|
| 1062 | private final Group cGroup = (Group)rule.eContents().get(1); |
---|
| 1063 | private final Keyword cNumberSignKeyword_0 = (Keyword)cGroup.eContents().get(0); |
---|
| 1064 | private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1); |
---|
| 1065 | private final Assignment cFromAssignment_2 = (Assignment)cGroup.eContents().get(2); |
---|
| 1066 | private final RuleCall cFromINTTerminalRuleCall_2_0 = (RuleCall)cFromAssignment_2.eContents().get(0); |
---|
| 1067 | private final Keyword cCommaKeyword_3 = (Keyword)cGroup.eContents().get(3); |
---|
| 1068 | private final Assignment cToAssignment_4 = (Assignment)cGroup.eContents().get(4); |
---|
| 1069 | private final RuleCall cToINTTerminalRuleCall_4_0 = (RuleCall)cToAssignment_4.eContents().get(0); |
---|
| 1070 | private final Keyword cRightParenthesisKeyword_5 = (Keyword)cGroup.eContents().get(5); |
---|
| 1071 | |
---|
| 1072 | //RepeatRange: |
---|
| 1073 | // "#" "(" from=INT "," to=INT ")"; |
---|
| 1074 | public ParserRule getRule() { return rule; } |
---|
| 1075 | |
---|
| 1076 | //"#" "(" from=INT "," to=INT ")" |
---|
| 1077 | public Group getGroup() { return cGroup; } |
---|
| 1078 | |
---|
| 1079 | //"#" |
---|
| 1080 | public Keyword getNumberSignKeyword_0() { return cNumberSignKeyword_0; } |
---|
| 1081 | |
---|
| 1082 | //"(" |
---|
| 1083 | public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; } |
---|
| 1084 | |
---|
| 1085 | //from=INT |
---|
| 1086 | public Assignment getFromAssignment_2() { return cFromAssignment_2; } |
---|
| 1087 | |
---|
| 1088 | //INT |
---|
| 1089 | public RuleCall getFromINTTerminalRuleCall_2_0() { return cFromINTTerminalRuleCall_2_0; } |
---|
| 1090 | |
---|
| 1091 | //"," |
---|
| 1092 | public Keyword getCommaKeyword_3() { return cCommaKeyword_3; } |
---|
| 1093 | |
---|
| 1094 | //to=INT |
---|
| 1095 | public Assignment getToAssignment_4() { return cToAssignment_4; } |
---|
| 1096 | |
---|
| 1097 | //INT |
---|
| 1098 | public RuleCall getToINTTerminalRuleCall_4_0() { return cToINTTerminalRuleCall_4_0; } |
---|
| 1099 | |
---|
| 1100 | //")" |
---|
| 1101 | public Keyword getRightParenthesisKeyword_5() { return cRightParenthesisKeyword_5; } |
---|
| 1102 | } |
---|
[61] | 1103 | |
---|
| 1104 | |
---|
| 1105 | private EtsiBnfElements pEtsiBnf; |
---|
| 1106 | private ImportSectionElements pImportSection; |
---|
| 1107 | private BnfEntryElements pBnfEntry; |
---|
| 1108 | private DeltaEntryElements pDeltaEntry; |
---|
| 1109 | private MergeEntryElements pMergeEntry; |
---|
| 1110 | private SectionHeadingElements pSectionHeading; |
---|
[100] | 1111 | private CommentElements pComment; |
---|
[61] | 1112 | private ImportElements pImport; |
---|
| 1113 | private RuleElements pRule; |
---|
| 1114 | private ExtRuleElements pExtRule; |
---|
| 1115 | private MergeRuleElements pMergeRule; |
---|
| 1116 | private GlobalCombinatorElements pGlobalCombinator; |
---|
| 1117 | private RuleCombinatorElements pRuleCombinator; |
---|
| 1118 | private HookCombinatorElements pHookCombinator; |
---|
| 1119 | private DefinitionListElements pDefinitionList; |
---|
| 1120 | private SingleDefinitionElements pSingleDefinition; |
---|
| 1121 | private TermElements pTerm; |
---|
| 1122 | private AtomElements pAtom; |
---|
| 1123 | private RuleReferenceElements pRuleReference; |
---|
| 1124 | private StringRuleElements pStringRule; |
---|
| 1125 | private GroupedSequenceElements pGroupedSequence; |
---|
| 1126 | private OptionalSequenceElements pOptionalSequence; |
---|
| 1127 | private RepeatedSequenceElements pRepeatedSequence; |
---|
[95] | 1128 | private RepeatRangeElements pRepeatRange; |
---|
[61] | 1129 | private TerminalRule tID; |
---|
| 1130 | private TerminalRule tINT; |
---|
| 1131 | private TerminalRule tWS; |
---|
| 1132 | private TerminalRule tCOLON; |
---|
| 1133 | private TerminalRule tSTRING; |
---|
| 1134 | private TerminalRule tSECTIONHEADER; |
---|
| 1135 | private TerminalRule tSL_COMMENT; |
---|
| 1136 | private TerminalRule tML_COMMENT; |
---|
| 1137 | private TerminalRule tLOGIC; |
---|
| 1138 | |
---|
| 1139 | private final Grammar grammar; |
---|
| 1140 | |
---|
| 1141 | @Inject |
---|
| 1142 | public EbnfGrammarAccess(GrammarProvider grammarProvider) { |
---|
| 1143 | this.grammar = internalFindGrammar(grammarProvider); |
---|
| 1144 | } |
---|
| 1145 | |
---|
| 1146 | protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { |
---|
| 1147 | Grammar grammar = grammarProvider.getGrammar(this); |
---|
| 1148 | while (grammar != null) { |
---|
| 1149 | if ("de.ugoe.cs.swe.bnftools.Ebnf".equals(grammar.getName())) { |
---|
| 1150 | return grammar; |
---|
| 1151 | } |
---|
| 1152 | List<Grammar> grammars = grammar.getUsedGrammars(); |
---|
| 1153 | if (!grammars.isEmpty()) { |
---|
| 1154 | grammar = grammars.iterator().next(); |
---|
| 1155 | } else { |
---|
| 1156 | return null; |
---|
| 1157 | } |
---|
| 1158 | } |
---|
| 1159 | return grammar; |
---|
| 1160 | } |
---|
| 1161 | |
---|
| 1162 | |
---|
| 1163 | public Grammar getGrammar() { |
---|
| 1164 | return grammar; |
---|
| 1165 | } |
---|
| 1166 | |
---|
| 1167 | |
---|
| 1168 | |
---|
| 1169 | //// -----------------------------------------------------------------------------------------------
|
---|
| 1170 | //// Parser Rules
|
---|
| 1171 | //// -----------------------------------------------------------------------------------------------
|
---|
[88] | 1172 | //EtsiBnf: |
---|
| 1173 | // "grammar" name=ID (type="/bnf"? ";" importSection=ImportSection? bnfEntry+=BnfEntry+) | type="/delta" ";" |
---|
| 1174 | // importSection=ImportSection? deltaEntry+=DeltaEntry* | type="/merge" ";" importSection=ImportSection? |
---|
[61] | 1175 | // mergeEntry+=MergeEntry*; |
---|
| 1176 | public EtsiBnfElements getEtsiBnfAccess() { |
---|
| 1177 | return (pEtsiBnf != null) ? pEtsiBnf : (pEtsiBnf = new EtsiBnfElements()); |
---|
| 1178 | } |
---|
| 1179 | |
---|
| 1180 | public ParserRule getEtsiBnfRule() { |
---|
| 1181 | return getEtsiBnfAccess().getRule(); |
---|
| 1182 | } |
---|
| 1183 | |
---|
[88] | 1184 | //ImportSection: |
---|
[61] | 1185 | // imports+=Import+; |
---|
| 1186 | public ImportSectionElements getImportSectionAccess() { |
---|
| 1187 | return (pImportSection != null) ? pImportSection : (pImportSection = new ImportSectionElements()); |
---|
| 1188 | } |
---|
| 1189 | |
---|
| 1190 | public ParserRule getImportSectionRule() { |
---|
| 1191 | return getImportSectionAccess().getRule(); |
---|
| 1192 | } |
---|
| 1193 | |
---|
[88] | 1194 | //BnfEntry: |
---|
[100] | 1195 | // sectionheader=SectionHeading | rule=Rule | comment=Comment; |
---|
[61] | 1196 | public BnfEntryElements getBnfEntryAccess() { |
---|
| 1197 | return (pBnfEntry != null) ? pBnfEntry : (pBnfEntry = new BnfEntryElements()); |
---|
| 1198 | } |
---|
| 1199 | |
---|
| 1200 | public ParserRule getBnfEntryRule() { |
---|
| 1201 | return getBnfEntryAccess().getRule(); |
---|
| 1202 | } |
---|
| 1203 | |
---|
[88] | 1204 | //DeltaEntry: |
---|
[61] | 1205 | // rule=Rule | sectionheader=SectionHeading | extRule=ExtRule; |
---|
| 1206 | public DeltaEntryElements getDeltaEntryAccess() { |
---|
| 1207 | return (pDeltaEntry != null) ? pDeltaEntry : (pDeltaEntry = new DeltaEntryElements()); |
---|
| 1208 | } |
---|
| 1209 | |
---|
| 1210 | public ParserRule getDeltaEntryRule() { |
---|
| 1211 | return getDeltaEntryAccess().getRule(); |
---|
| 1212 | } |
---|
| 1213 | |
---|
[88] | 1214 | //MergeEntry: |
---|
[61] | 1215 | // sectionheader=SectionHeading | mergeRule=MergeRule; |
---|
| 1216 | public MergeEntryElements getMergeEntryAccess() { |
---|
| 1217 | return (pMergeEntry != null) ? pMergeEntry : (pMergeEntry = new MergeEntryElements()); |
---|
| 1218 | } |
---|
| 1219 | |
---|
| 1220 | public ParserRule getMergeEntryRule() { |
---|
| 1221 | return getMergeEntryAccess().getRule(); |
---|
| 1222 | } |
---|
| 1223 | |
---|
[88] | 1224 | //SectionHeading: |
---|
[61] | 1225 | // {SectionHeading} sectionHeader=SECTIONHEADER; |
---|
| 1226 | public SectionHeadingElements getSectionHeadingAccess() { |
---|
| 1227 | return (pSectionHeading != null) ? pSectionHeading : (pSectionHeading = new SectionHeadingElements()); |
---|
| 1228 | } |
---|
| 1229 | |
---|
| 1230 | public ParserRule getSectionHeadingRule() { |
---|
| 1231 | return getSectionHeadingAccess().getRule(); |
---|
| 1232 | } |
---|
| 1233 | |
---|
[100] | 1234 | //Comment: |
---|
| 1235 | // {Comment} content=ML_COMMENT; |
---|
| 1236 | public CommentElements getCommentAccess() { |
---|
| 1237 | return (pComment != null) ? pComment : (pComment = new CommentElements()); |
---|
| 1238 | } |
---|
| 1239 | |
---|
| 1240 | public ParserRule getCommentRule() { |
---|
| 1241 | return getCommentAccess().getRule(); |
---|
| 1242 | } |
---|
| 1243 | |
---|
[88] | 1244 | //Import: |
---|
| 1245 | // "import" importURI=STRING ("/" (grammarType="core" | grammarType="package" | grammarType="update"))? ("label:" |
---|
[61] | 1246 | // label=ID)? ";"; |
---|
| 1247 | public ImportElements getImportAccess() { |
---|
| 1248 | return (pImport != null) ? pImport : (pImport = new ImportElements()); |
---|
| 1249 | } |
---|
| 1250 | |
---|
| 1251 | public ParserRule getImportRule() { |
---|
| 1252 | return getImportAccess().getRule(); |
---|
| 1253 | } |
---|
| 1254 | |
---|
[65] | 1255 | ////Import: 'import' importedNamespace=FqnWithWildCard;
|
---|
| 1256 | ////FqnWithWildCard: Fqn('.*')? ';';
|
---|
| 1257 | ////Fqn:ID('.'ID)*;
|
---|
[88] | 1258 | //Rule: |
---|
[61] | 1259 | // (rulenumber=INT rulevariant=ID? ".")? name=ID "::=" definitionList=DefinitionList? ";"?; |
---|
| 1260 | public RuleElements getRuleAccess() { |
---|
| 1261 | return (pRule != null) ? pRule : (pRule = new RuleElements()); |
---|
| 1262 | } |
---|
| 1263 | |
---|
| 1264 | public ParserRule getRuleRule() { |
---|
| 1265 | return getRuleAccess().getRule(); |
---|
| 1266 | } |
---|
| 1267 | |
---|
[88] | 1268 | //ExtRule: |
---|
| 1269 | // (rulenumber=INT rulevariant=ID? ".")? name=ID ("(" ruleext=INT ")") "<-" (elements+=Atom | ")" | "]" | "}" | "|" | "(" |
---|
| 1270 | // | "[" | "{" | "*" | "+")* ";"?; |
---|
[61] | 1271 | public ExtRuleElements getExtRuleAccess() { |
---|
| 1272 | return (pExtRule != null) ? pExtRule : (pExtRule = new ExtRuleElements()); |
---|
| 1273 | } |
---|
| 1274 | |
---|
| 1275 | public ParserRule getExtRuleRule() { |
---|
| 1276 | return getExtRuleAccess().getRule(); |
---|
| 1277 | } |
---|
| 1278 | |
---|
[88] | 1279 | //MergeRule: |
---|
[61] | 1280 | // GlobalCombinator | RuleCombinator | HookCombinator; |
---|
| 1281 | public MergeRuleElements getMergeRuleAccess() { |
---|
| 1282 | return (pMergeRule != null) ? pMergeRule : (pMergeRule = new MergeRuleElements()); |
---|
| 1283 | } |
---|
| 1284 | |
---|
| 1285 | public ParserRule getMergeRuleRule() { |
---|
| 1286 | return getMergeRuleAccess().getRule(); |
---|
| 1287 | } |
---|
| 1288 | |
---|
[88] | 1289 | //GlobalCombinator: |
---|
[61] | 1290 | // ("global" "combinator:") logic=LOGIC ";"?; |
---|
| 1291 | public GlobalCombinatorElements getGlobalCombinatorAccess() { |
---|
| 1292 | return (pGlobalCombinator != null) ? pGlobalCombinator : (pGlobalCombinator = new GlobalCombinatorElements()); |
---|
| 1293 | } |
---|
| 1294 | |
---|
| 1295 | public ParserRule getGlobalCombinatorRule() { |
---|
| 1296 | return getGlobalCombinatorAccess().getRule(); |
---|
| 1297 | } |
---|
| 1298 | |
---|
[88] | 1299 | //RuleCombinator: |
---|
[61] | 1300 | // ("rule" "combinator:" name=ID) logic=LOGIC ("(" LABEL+=STRING ")")* ";"?; |
---|
| 1301 | public RuleCombinatorElements getRuleCombinatorAccess() { |
---|
| 1302 | return (pRuleCombinator != null) ? pRuleCombinator : (pRuleCombinator = new RuleCombinatorElements()); |
---|
| 1303 | } |
---|
| 1304 | |
---|
| 1305 | public ParserRule getRuleCombinatorRule() { |
---|
| 1306 | return getRuleCombinatorAccess().getRule(); |
---|
| 1307 | } |
---|
| 1308 | |
---|
[88] | 1309 | //HookCombinator: |
---|
[61] | 1310 | // "hook" "combinator:" name=ID "(" ruleext=INT ")" logic=LOGIC? ("(" LABEL+=STRING ")")+ ";"?; |
---|
| 1311 | public HookCombinatorElements getHookCombinatorAccess() { |
---|
| 1312 | return (pHookCombinator != null) ? pHookCombinator : (pHookCombinator = new HookCombinatorElements()); |
---|
| 1313 | } |
---|
| 1314 | |
---|
| 1315 | public ParserRule getHookCombinatorRule() { |
---|
| 1316 | return getHookCombinatorAccess().getRule(); |
---|
| 1317 | } |
---|
| 1318 | |
---|
[88] | 1319 | //DefinitionList: |
---|
[61] | 1320 | // singleDefinition+=SingleDefinition ("|" singleDefinition+=SingleDefinition)*; |
---|
| 1321 | public DefinitionListElements getDefinitionListAccess() { |
---|
| 1322 | return (pDefinitionList != null) ? pDefinitionList : (pDefinitionList = new DefinitionListElements()); |
---|
| 1323 | } |
---|
| 1324 | |
---|
| 1325 | public ParserRule getDefinitionListRule() { |
---|
| 1326 | return getDefinitionListAccess().getRule(); |
---|
| 1327 | } |
---|
| 1328 | |
---|
[88] | 1329 | //SingleDefinition: |
---|
[61] | 1330 | // terms+=Term+; |
---|
| 1331 | public SingleDefinitionElements getSingleDefinitionAccess() { |
---|
| 1332 | return (pSingleDefinition != null) ? pSingleDefinition : (pSingleDefinition = new SingleDefinitionElements()); |
---|
| 1333 | } |
---|
| 1334 | |
---|
| 1335 | public ParserRule getSingleDefinitionRule() { |
---|
| 1336 | return getSingleDefinitionAccess().getRule(); |
---|
| 1337 | } |
---|
| 1338 | |
---|
[88] | 1339 | //Term: |
---|
| 1340 | // termAtom=Atom | termGroupedSequence=GroupedSequence | termOptionalSequence=OptionalSequence | |
---|
[61] | 1341 | // termRepeatedSequence=RepeatedSequence; |
---|
| 1342 | public TermElements getTermAccess() { |
---|
| 1343 | return (pTerm != null) ? pTerm : (pTerm = new TermElements()); |
---|
| 1344 | } |
---|
| 1345 | |
---|
| 1346 | public ParserRule getTermRule() { |
---|
| 1347 | return getTermAccess().getRule(); |
---|
| 1348 | } |
---|
| 1349 | |
---|
[88] | 1350 | //Atom: |
---|
[61] | 1351 | // atomStringRule=StringRule | atomRuleReference=RuleReference; |
---|
| 1352 | public AtomElements getAtomAccess() { |
---|
| 1353 | return (pAtom != null) ? pAtom : (pAtom = new AtomElements()); |
---|
| 1354 | } |
---|
| 1355 | |
---|
| 1356 | public ParserRule getAtomRule() { |
---|
| 1357 | return getAtomAccess().getRule(); |
---|
| 1358 | } |
---|
| 1359 | |
---|
[88] | 1360 | //RuleReference: |
---|
[61] | 1361 | // ruleref=[Rule]; |
---|
| 1362 | public RuleReferenceElements getRuleReferenceAccess() { |
---|
| 1363 | return (pRuleReference != null) ? pRuleReference : (pRuleReference = new RuleReferenceElements()); |
---|
| 1364 | } |
---|
| 1365 | |
---|
| 1366 | public ParserRule getRuleReferenceRule() { |
---|
| 1367 | return getRuleReferenceAccess().getRule(); |
---|
| 1368 | } |
---|
| 1369 | |
---|
[88] | 1370 | //StringRule: |
---|
[61] | 1371 | // literal=STRING | colon=COLON; |
---|
| 1372 | public StringRuleElements getStringRuleAccess() { |
---|
| 1373 | return (pStringRule != null) ? pStringRule : (pStringRule = new StringRuleElements()); |
---|
| 1374 | } |
---|
| 1375 | |
---|
| 1376 | public ParserRule getStringRuleRule() { |
---|
| 1377 | return getStringRuleAccess().getRule(); |
---|
| 1378 | } |
---|
| 1379 | |
---|
[88] | 1380 | //GroupedSequence: |
---|
[61] | 1381 | // "(" definitionList+=DefinitionList ")"; |
---|
| 1382 | public GroupedSequenceElements getGroupedSequenceAccess() { |
---|
| 1383 | return (pGroupedSequence != null) ? pGroupedSequence : (pGroupedSequence = new GroupedSequenceElements()); |
---|
| 1384 | } |
---|
| 1385 | |
---|
| 1386 | public ParserRule getGroupedSequenceRule() { |
---|
| 1387 | return getGroupedSequenceAccess().getRule(); |
---|
| 1388 | } |
---|
| 1389 | |
---|
[88] | 1390 | //OptionalSequence: |
---|
[61] | 1391 | // "[" definitionList+=DefinitionList "]"; |
---|
| 1392 | public OptionalSequenceElements getOptionalSequenceAccess() { |
---|
| 1393 | return (pOptionalSequence != null) ? pOptionalSequence : (pOptionalSequence = new OptionalSequenceElements()); |
---|
| 1394 | } |
---|
| 1395 | |
---|
| 1396 | public ParserRule getOptionalSequenceRule() { |
---|
| 1397 | return getOptionalSequenceAccess().getRule(); |
---|
| 1398 | } |
---|
| 1399 | |
---|
[88] | 1400 | //RepeatedSequence: |
---|
[95] | 1401 | // "{" definitions+=DefinitionList "}" (morethanonce?="+"? | range=RepeatRange?); |
---|
[61] | 1402 | public RepeatedSequenceElements getRepeatedSequenceAccess() { |
---|
| 1403 | return (pRepeatedSequence != null) ? pRepeatedSequence : (pRepeatedSequence = new RepeatedSequenceElements()); |
---|
| 1404 | } |
---|
| 1405 | |
---|
| 1406 | public ParserRule getRepeatedSequenceRule() { |
---|
| 1407 | return getRepeatedSequenceAccess().getRule(); |
---|
| 1408 | } |
---|
| 1409 | |
---|
[95] | 1410 | //RepeatRange: |
---|
| 1411 | // "#" "(" from=INT "," to=INT ")"; |
---|
| 1412 | public RepeatRangeElements getRepeatRangeAccess() { |
---|
| 1413 | return (pRepeatRange != null) ? pRepeatRange : (pRepeatRange = new RepeatRangeElements()); |
---|
| 1414 | } |
---|
| 1415 | |
---|
| 1416 | public ParserRule getRepeatRangeRule() { |
---|
| 1417 | return getRepeatRangeAccess().getRule(); |
---|
| 1418 | } |
---|
| 1419 | |
---|
[61] | 1420 | //// -----------------------------------------------------------------------------------------------
|
---|
| 1421 | //// Lexer Rules
|
---|
| 1422 | //// -----------------------------------------------------------------------------------------------
|
---|
[88] | 1423 | //terminal ID: |
---|
[61] | 1424 | // ("a".."z" | "A".."Z" | "_") ("a".."z" | "A".."Z" | "0".."9" | "_")*; |
---|
| 1425 | public TerminalRule getIDRule() { |
---|
| 1426 | return (tID != null) ? tID : (tID = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "ID")); |
---|
| 1427 | } |
---|
| 1428 | |
---|
[88] | 1429 | //terminal INT returns ecore::EInt: |
---|
[61] | 1430 | // "0".."9"+; |
---|
| 1431 | public TerminalRule getINTRule() { |
---|
| 1432 | return (tINT != null) ? tINT : (tINT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "INT")); |
---|
| 1433 | } |
---|
| 1434 | |
---|
[88] | 1435 | //terminal WS: |
---|
[61] | 1436 | // (" " | "\t" | "\r"? "\n")+; |
---|
| 1437 | public TerminalRule getWSRule() { |
---|
| 1438 | return (tWS != null) ? tWS : (tWS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "WS")); |
---|
| 1439 | } |
---|
| 1440 | |
---|
[88] | 1441 | //terminal COLON: |
---|
[61] | 1442 | // "\"" "\"" "\""; |
---|
| 1443 | public TerminalRule getCOLONRule() { |
---|
| 1444 | return (tCOLON != null) ? tCOLON : (tCOLON = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "COLON")); |
---|
| 1445 | } |
---|
| 1446 | |
---|
[88] | 1447 | //terminal STRING: |
---|
[61] | 1448 | // "\"" !"\""* "\"" | "\'" !"\'"* "\'"; |
---|
| 1449 | public TerminalRule getSTRINGRule() { |
---|
| 1450 | return (tSTRING != null) ? tSTRING : (tSTRING = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "STRING")); |
---|
| 1451 | } |
---|
| 1452 | |
---|
[88] | 1453 | //terminal SECTIONHEADER: |
---|
[61] | 1454 | // ("a".."z" | "A".."Z") ("." | "0".."9")+ (" " | "\t") !("\n" | "\r")* "\r"? "\n"; |
---|
| 1455 | public TerminalRule getSECTIONHEADERRule() { |
---|
| 1456 | return (tSECTIONHEADER != null) ? tSECTIONHEADER : (tSECTIONHEADER = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "SECTIONHEADER")); |
---|
| 1457 | } |
---|
| 1458 | |
---|
[88] | 1459 | //terminal SL_COMMENT: |
---|
[61] | 1460 | // "//" !("\n" | "\r")* ("\r"? "\n")?; |
---|
| 1461 | public TerminalRule getSL_COMMENTRule() { |
---|
| 1462 | return (tSL_COMMENT != null) ? tSL_COMMENT : (tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "SL_COMMENT")); |
---|
| 1463 | } |
---|
| 1464 | |
---|
[88] | 1465 | //terminal ML_COMMENT: |
---|
[61] | 1466 | // "/ *"->"* /"; |
---|
| 1467 | public TerminalRule getML_COMMENTRule() { |
---|
| 1468 | return (tML_COMMENT != null) ? tML_COMMENT : (tML_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "ML_COMMENT")); |
---|
| 1469 | } |
---|
| 1470 | |
---|
| 1471 | ////TODO: a more intuitive notation
|
---|
[88] | 1472 | //terminal LOGIC: |
---|
[61] | 1473 | // "/and" | "/or" | "/andr" | "/orr" | "/any" | "/together"; |
---|
| 1474 | public TerminalRule getLOGICRule() { |
---|
| 1475 | return (tLOGIC != null) ? tLOGIC : (tLOGIC = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "LOGIC")); |
---|
| 1476 | } |
---|
| 1477 | } |
---|