aboutsummaryrefslogtreecommitdiffstats
path: root/Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g
diff options
context:
space:
mode:
Diffstat (limited to 'Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g')
-rw-r--r--Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g22282
1 files changed, 11794 insertions, 10488 deletions
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g b/Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g
index e9a91938..ae1ad469 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g
+++ b/Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g
@@ -1,10488 +1,11794 @@
1/* 1/*
2 * generated by Xtext 2.12.0 2 * generated by Xtext 2.16.0
3 */ 3 */
4grammar InternalApplicationConfiguration; 4grammar InternalApplicationConfiguration;
5 5
6options { 6options {
7 superClass=AbstractInternalContentAssistParser; 7 superClass=AbstractInternalContentAssistParser;
8} 8}
9 9
10@lexer::header { 10@lexer::header {
11package hu.bme.mit.inf.dslreasoner.application.ide.contentassist.antlr.internal; 11package hu.bme.mit.inf.dslreasoner.application.ide.contentassist.antlr.internal;
12 12
13// Hack: Use our own Lexer superclass by means of import. 13// Hack: Use our own Lexer superclass by means of import.
14// Currently there is no other way to specify the superclass for the lexer. 14// Currently there is no other way to specify the superclass for the lexer.
15import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; 15import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
16} 16}
17 17
18@parser::header { 18@parser::header {
19package hu.bme.mit.inf.dslreasoner.application.ide.contentassist.antlr.internal; 19package hu.bme.mit.inf.dslreasoner.application.ide.contentassist.antlr.internal;
20 20
21import java.io.InputStream; 21import java.io.InputStream;
22import org.eclipse.xtext.*; 22import org.eclipse.xtext.*;
23import org.eclipse.xtext.parser.*; 23import org.eclipse.xtext.parser.*;
24import org.eclipse.xtext.parser.impl.*; 24import org.eclipse.xtext.parser.impl.*;
25import org.eclipse.emf.ecore.util.EcoreUtil; 25import org.eclipse.emf.ecore.util.EcoreUtil;
26import org.eclipse.emf.ecore.EObject; 26import org.eclipse.emf.ecore.EObject;
27import org.eclipse.xtext.parser.antlr.XtextTokenStream; 27import org.eclipse.xtext.parser.antlr.XtextTokenStream;
28import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; 28import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
29import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; 29import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
30import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA; 30import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
31import hu.bme.mit.inf.dslreasoner.application.services.ApplicationConfigurationGrammarAccess; 31import hu.bme.mit.inf.dslreasoner.application.services.ApplicationConfigurationGrammarAccess;
32 32
33} 33}
34@parser::members { 34@parser::members {
35 private ApplicationConfigurationGrammarAccess grammarAccess; 35 private ApplicationConfigurationGrammarAccess grammarAccess;
36 36
37 public void setGrammarAccess(ApplicationConfigurationGrammarAccess grammarAccess) { 37 public void setGrammarAccess(ApplicationConfigurationGrammarAccess grammarAccess) {
38 this.grammarAccess = grammarAccess; 38 this.grammarAccess = grammarAccess;
39 } 39 }
40 40
41 @Override 41 @Override
42 protected Grammar getGrammar() { 42 protected Grammar getGrammar() {
43 return grammarAccess.getGrammar(); 43 return grammarAccess.getGrammar();
44 } 44 }
45 45
46 @Override 46 @Override
47 protected String getValueForTokenName(String tokenName) { 47 protected String getValueForTokenName(String tokenName) {
48 return tokenName; 48 return tokenName;
49 } 49 }
50} 50}
51 51
52// Entry rule entryRuleConfigurationScript 52// Entry rule entryRuleConfigurationScript
53entryRuleConfigurationScript 53entryRuleConfigurationScript
54: 54:
55{ before(grammarAccess.getConfigurationScriptRule()); } 55{ before(grammarAccess.getConfigurationScriptRule()); }
56 ruleConfigurationScript 56 ruleConfigurationScript
57{ after(grammarAccess.getConfigurationScriptRule()); } 57{ after(grammarAccess.getConfigurationScriptRule()); }
58 EOF 58 EOF
59; 59;
60 60
61// Rule ConfigurationScript 61// Rule ConfigurationScript
62ruleConfigurationScript 62ruleConfigurationScript
63 @init { 63 @init {
64 int stackSize = keepStackSize(); 64 int stackSize = keepStackSize();
65 } 65 }
66 : 66 :
67 ( 67 (
68 { before(grammarAccess.getConfigurationScriptAccess().getGroup()); } 68 { before(grammarAccess.getConfigurationScriptAccess().getGroup()); }
69 (rule__ConfigurationScript__Group__0) 69 (rule__ConfigurationScript__Group__0)
70 { after(grammarAccess.getConfigurationScriptAccess().getGroup()); } 70 { after(grammarAccess.getConfigurationScriptAccess().getGroup()); }
71 ) 71 )
72; 72;
73finally { 73finally {
74 restoreStackSize(stackSize); 74 restoreStackSize(stackSize);
75} 75}
76 76
77// Entry rule entryRuleCommand 77// Entry rule entryRuleCommand
78entryRuleCommand 78entryRuleCommand
79: 79:
80{ before(grammarAccess.getCommandRule()); } 80{ before(grammarAccess.getCommandRule()); }
81 ruleCommand 81 ruleCommand
82{ after(grammarAccess.getCommandRule()); } 82{ after(grammarAccess.getCommandRule()); }
83 EOF 83 EOF
84; 84;
85 85
86// Rule Command 86// Rule Command
87ruleCommand 87ruleCommand
88 @init { 88 @init {
89 int stackSize = keepStackSize(); 89 int stackSize = keepStackSize();
90 } 90 }
91 : 91 :
92 ( 92 (
93 { before(grammarAccess.getCommandAccess().getAlternatives()); } 93 { before(grammarAccess.getCommandAccess().getAlternatives()); }
94 (rule__Command__Alternatives) 94 (rule__Command__Alternatives)
95 { after(grammarAccess.getCommandAccess().getAlternatives()); } 95 { after(grammarAccess.getCommandAccess().getAlternatives()); }
96 ) 96 )
97; 97;
98finally { 98finally {
99 restoreStackSize(stackSize); 99 restoreStackSize(stackSize);
100} 100}
101 101
102// Entry rule entryRuleQualifiedName 102// Entry rule entryRuleQualifiedName
103entryRuleQualifiedName 103entryRuleQualifiedName
104: 104:
105{ before(grammarAccess.getQualifiedNameRule()); } 105{ before(grammarAccess.getQualifiedNameRule()); }
106 ruleQualifiedName 106 ruleQualifiedName
107{ after(grammarAccess.getQualifiedNameRule()); } 107{ after(grammarAccess.getQualifiedNameRule()); }
108 EOF 108 EOF
109; 109;
110 110
111// Rule QualifiedName 111// Rule QualifiedName
112ruleQualifiedName 112ruleQualifiedName
113 @init { 113 @init {
114 int stackSize = keepStackSize(); 114 int stackSize = keepStackSize();
115 } 115 }
116 : 116 :
117 ( 117 (
118 { before(grammarAccess.getQualifiedNameAccess().getGroup()); } 118 { before(grammarAccess.getQualifiedNameAccess().getGroup()); }
119 (rule__QualifiedName__Group__0) 119 (rule__QualifiedName__Group__0)
120 { after(grammarAccess.getQualifiedNameAccess().getGroup()); } 120 { after(grammarAccess.getQualifiedNameAccess().getGroup()); }
121 ) 121 )
122; 122;
123finally { 123finally {
124 restoreStackSize(stackSize); 124 restoreStackSize(stackSize);
125} 125}
126 126
127// Entry rule entryRuleREALLiteral 127// Entry rule entryRuleREALLiteral
128entryRuleREALLiteral 128entryRuleREALLiteral
129: 129:
130{ before(grammarAccess.getREALLiteralRule()); } 130{ before(grammarAccess.getREALLiteralRule()); }
131 ruleREALLiteral 131 ruleREALLiteral
132{ after(grammarAccess.getREALLiteralRule()); } 132{ after(grammarAccess.getREALLiteralRule()); }
133 EOF 133 EOF
134; 134;
135 135
136// Rule REALLiteral 136// Rule REALLiteral
137ruleREALLiteral 137ruleREALLiteral
138 @init { 138 @init {
139 int stackSize = keepStackSize(); 139 int stackSize = keepStackSize();
140 } 140 }
141 : 141 :
142 ( 142 (
143 { before(grammarAccess.getREALLiteralAccess().getGroup()); } 143 { before(grammarAccess.getREALLiteralAccess().getGroup()); }
144 (rule__REALLiteral__Group__0) 144 (rule__REALLiteral__Group__0)
145 { after(grammarAccess.getREALLiteralAccess().getGroup()); } 145 { after(grammarAccess.getREALLiteralAccess().getGroup()); }
146 ) 146 )
147; 147;
148finally { 148finally {
149 restoreStackSize(stackSize); 149 restoreStackSize(stackSize);
150} 150}
151 151
152// Entry rule entryRuleINTLiteral 152// Entry rule entryRuleINTLiteral
153entryRuleINTLiteral 153entryRuleINTLiteral
154: 154:
155{ before(grammarAccess.getINTLiteralRule()); } 155{ before(grammarAccess.getINTLiteralRule()); }
156 ruleINTLiteral 156 ruleINTLiteral
157{ after(grammarAccess.getINTLiteralRule()); } 157{ after(grammarAccess.getINTLiteralRule()); }
158 EOF 158 EOF
159; 159;
160 160
161// Rule INTLiteral 161// Rule INTLiteral
162ruleINTLiteral 162ruleINTLiteral
163 @init { 163 @init {
164 int stackSize = keepStackSize(); 164 int stackSize = keepStackSize();
165 } 165 }
166 : 166 :
167 ( 167 (
168 { before(grammarAccess.getINTLiteralAccess().getGroup()); } 168 { before(grammarAccess.getINTLiteralAccess().getGroup()); }
169 (rule__INTLiteral__Group__0) 169 (rule__INTLiteral__Group__0)
170 { after(grammarAccess.getINTLiteralAccess().getGroup()); } 170 { after(grammarAccess.getINTLiteralAccess().getGroup()); }
171 ) 171 )
172; 172;
173finally { 173finally {
174 restoreStackSize(stackSize); 174 restoreStackSize(stackSize);
175} 175}
176 176
177// Entry rule entryRuleImport 177// Entry rule entryRuleImport
178entryRuleImport 178entryRuleImport
179: 179:
180{ before(grammarAccess.getImportRule()); } 180{ before(grammarAccess.getImportRule()); }
181 ruleImport 181 ruleImport
182{ after(grammarAccess.getImportRule()); } 182{ after(grammarAccess.getImportRule()); }
183 EOF 183 EOF
184; 184;
185 185
186// Rule Import 186// Rule Import
187ruleImport 187ruleImport
188 @init { 188 @init {
189 int stackSize = keepStackSize(); 189 int stackSize = keepStackSize();
190 } 190 }
191 : 191 :
192 ( 192 (
193 { before(grammarAccess.getImportAccess().getAlternatives()); } 193 { before(grammarAccess.getImportAccess().getAlternatives()); }
194 (rule__Import__Alternatives) 194 (rule__Import__Alternatives)
195 { after(grammarAccess.getImportAccess().getAlternatives()); } 195 { after(grammarAccess.getImportAccess().getAlternatives()); }
196 ) 196 )
197; 197;
198finally { 198finally {
199 restoreStackSize(stackSize); 199 restoreStackSize(stackSize);
200} 200}
201 201
202// Entry rule entryRuleEPackageImport 202// Entry rule entryRuleEPackageImport
203entryRuleEPackageImport 203entryRuleEPackageImport
204: 204:
205{ before(grammarAccess.getEPackageImportRule()); } 205{ before(grammarAccess.getEPackageImportRule()); }
206 ruleEPackageImport 206 ruleEPackageImport
207{ after(grammarAccess.getEPackageImportRule()); } 207{ after(grammarAccess.getEPackageImportRule()); }
208 EOF 208 EOF
209; 209;
210 210
211// Rule EPackageImport 211// Rule EPackageImport
212ruleEPackageImport 212ruleEPackageImport
213 @init { 213 @init {
214 int stackSize = keepStackSize(); 214 int stackSize = keepStackSize();
215 } 215 }
216 : 216 :
217 ( 217 (
218 { before(grammarAccess.getEPackageImportAccess().getGroup()); } 218 { before(grammarAccess.getEPackageImportAccess().getGroup()); }
219 (rule__EPackageImport__Group__0) 219 (rule__EPackageImport__Group__0)
220 { after(grammarAccess.getEPackageImportAccess().getGroup()); } 220 { after(grammarAccess.getEPackageImportAccess().getGroup()); }
221 ) 221 )
222; 222;
223finally { 223finally {
224 restoreStackSize(stackSize); 224 restoreStackSize(stackSize);
225} 225}
226 226
227// Entry rule entryRuleViatraImport 227// Entry rule entryRuleViatraImport
228entryRuleViatraImport 228entryRuleViatraImport
229: 229:
230{ before(grammarAccess.getViatraImportRule()); } 230{ before(grammarAccess.getViatraImportRule()); }
231 ruleViatraImport 231 ruleViatraImport
232{ after(grammarAccess.getViatraImportRule()); } 232{ after(grammarAccess.getViatraImportRule()); }
233 EOF 233 EOF
234; 234;
235 235
236// Rule ViatraImport 236// Rule ViatraImport
237ruleViatraImport 237ruleViatraImport
238 @init { 238 @init {
239 int stackSize = keepStackSize(); 239 int stackSize = keepStackSize();
240 } 240 }
241 : 241 :
242 ( 242 (
243 { before(grammarAccess.getViatraImportAccess().getGroup()); } 243 { before(grammarAccess.getViatraImportAccess().getGroup()); }
244 (rule__ViatraImport__Group__0) 244 (rule__ViatraImport__Group__0)
245 { after(grammarAccess.getViatraImportAccess().getGroup()); } 245 { after(grammarAccess.getViatraImportAccess().getGroup()); }
246 ) 246 )
247; 247;
248finally { 248finally {
249 restoreStackSize(stackSize); 249 restoreStackSize(stackSize);
250} 250}
251 251
252// Entry rule entryRuleDeclaration 252// Entry rule entryRuleCftImport
253entryRuleDeclaration 253entryRuleCftImport
254: 254:
255{ before(grammarAccess.getDeclarationRule()); } 255{ before(grammarAccess.getCftImportRule()); }
256 ruleDeclaration 256 ruleCftImport
257{ after(grammarAccess.getDeclarationRule()); } 257{ after(grammarAccess.getCftImportRule()); }
258 EOF 258 EOF
259; 259;
260 260
261// Rule Declaration 261// Rule CftImport
262ruleDeclaration 262ruleCftImport
263 @init { 263 @init {
264 int stackSize = keepStackSize(); 264 int stackSize = keepStackSize();
265 } 265 }
266 : 266 :
267 ( 267 (
268 { before(grammarAccess.getDeclarationAccess().getAlternatives()); } 268 { before(grammarAccess.getCftImportAccess().getGroup()); }
269 (rule__Declaration__Alternatives) 269 (rule__CftImport__Group__0)
270 { after(grammarAccess.getDeclarationAccess().getAlternatives()); } 270 { after(grammarAccess.getCftImportAccess().getGroup()); }
271 ) 271 )
272; 272;
273finally { 273finally {
274 restoreStackSize(stackSize); 274 restoreStackSize(stackSize);
275} 275}
276 276
277// Entry rule entryRuleFileSpecification 277// Entry rule entryRuleDeclaration
278entryRuleFileSpecification 278entryRuleDeclaration
279: 279:
280{ before(grammarAccess.getFileSpecificationRule()); } 280{ before(grammarAccess.getDeclarationRule()); }
281 ruleFileSpecification 281 ruleDeclaration
282{ after(grammarAccess.getFileSpecificationRule()); } 282{ after(grammarAccess.getDeclarationRule()); }
283 EOF 283 EOF
284; 284;
285 285
286// Rule FileSpecification 286// Rule Declaration
287ruleFileSpecification 287ruleDeclaration
288 @init { 288 @init {
289 int stackSize = keepStackSize(); 289 int stackSize = keepStackSize();
290 } 290 }
291 : 291 :
292 ( 292 (
293 { before(grammarAccess.getFileSpecificationAccess().getPathAssignment()); } 293 { before(grammarAccess.getDeclarationAccess().getAlternatives()); }
294 (rule__FileSpecification__PathAssignment) 294 (rule__Declaration__Alternatives)
295 { after(grammarAccess.getFileSpecificationAccess().getPathAssignment()); } 295 { after(grammarAccess.getDeclarationAccess().getAlternatives()); }
296 ) 296 )
297; 297;
298finally { 298finally {
299 restoreStackSize(stackSize); 299 restoreStackSize(stackSize);
300} 300}
301 301
302// Entry rule entryRuleFileDeclaration 302// Entry rule entryRuleFileSpecification
303entryRuleFileDeclaration 303entryRuleFileSpecification
304: 304:
305{ before(grammarAccess.getFileDeclarationRule()); } 305{ before(grammarAccess.getFileSpecificationRule()); }
306 ruleFileDeclaration 306 ruleFileSpecification
307{ after(grammarAccess.getFileDeclarationRule()); } 307{ after(grammarAccess.getFileSpecificationRule()); }
308 EOF 308 EOF
309; 309;
310 310
311// Rule FileDeclaration 311// Rule FileSpecification
312ruleFileDeclaration 312ruleFileSpecification
313 @init { 313 @init {
314 int stackSize = keepStackSize(); 314 int stackSize = keepStackSize();
315 } 315 }
316 : 316 :
317 ( 317 (
318 { before(grammarAccess.getFileDeclarationAccess().getGroup()); } 318 { before(grammarAccess.getFileSpecificationAccess().getPathAssignment()); }
319 (rule__FileDeclaration__Group__0) 319 (rule__FileSpecification__PathAssignment)
320 { after(grammarAccess.getFileDeclarationAccess().getGroup()); } 320 { after(grammarAccess.getFileSpecificationAccess().getPathAssignment()); }
321 ) 321 )
322; 322;
323finally { 323finally {
324 restoreStackSize(stackSize); 324 restoreStackSize(stackSize);
325} 325}
326 326
327// Entry rule entryRuleFileReference 327// Entry rule entryRuleFileDeclaration
328entryRuleFileReference 328entryRuleFileDeclaration
329: 329:
330{ before(grammarAccess.getFileReferenceRule()); } 330{ before(grammarAccess.getFileDeclarationRule()); }
331 ruleFileReference 331 ruleFileDeclaration
332{ after(grammarAccess.getFileReferenceRule()); } 332{ after(grammarAccess.getFileDeclarationRule()); }
333 EOF 333 EOF
334; 334;
335 335
336// Rule FileReference 336// Rule FileDeclaration
337ruleFileReference 337ruleFileDeclaration
338 @init { 338 @init {
339 int stackSize = keepStackSize(); 339 int stackSize = keepStackSize();
340 } 340 }
341 : 341 :
342 ( 342 (
343 { before(grammarAccess.getFileReferenceAccess().getReferredAssignment()); } 343 { before(grammarAccess.getFileDeclarationAccess().getGroup()); }
344 (rule__FileReference__ReferredAssignment) 344 (rule__FileDeclaration__Group__0)
345 { after(grammarAccess.getFileReferenceAccess().getReferredAssignment()); } 345 { after(grammarAccess.getFileDeclarationAccess().getGroup()); }
346 ) 346 )
347; 347;
348finally { 348finally {
349 restoreStackSize(stackSize); 349 restoreStackSize(stackSize);
350} 350}
351 351
352// Entry rule entryRuleFile 352// Entry rule entryRuleFileReference
353entryRuleFile 353entryRuleFileReference
354: 354:
355{ before(grammarAccess.getFileRule()); } 355{ before(grammarAccess.getFileReferenceRule()); }
356 ruleFile 356 ruleFileReference
357{ after(grammarAccess.getFileRule()); } 357{ after(grammarAccess.getFileReferenceRule()); }
358 EOF 358 EOF
359; 359;
360 360
361// Rule File 361// Rule FileReference
362ruleFile 362ruleFileReference
363 @init { 363 @init {
364 int stackSize = keepStackSize(); 364 int stackSize = keepStackSize();
365 } 365 }
366 : 366 :
367 ( 367 (
368 { before(grammarAccess.getFileAccess().getAlternatives()); } 368 { before(grammarAccess.getFileReferenceAccess().getReferredAssignment()); }
369 (rule__File__Alternatives) 369 (rule__FileReference__ReferredAssignment)
370 { after(grammarAccess.getFileAccess().getAlternatives()); } 370 { after(grammarAccess.getFileReferenceAccess().getReferredAssignment()); }
371 ) 371 )
372; 372;
373finally { 373finally {
374 restoreStackSize(stackSize); 374 restoreStackSize(stackSize);
375} 375}
376 376
377// Entry rule entryRuleMetamodelSpecification 377// Entry rule entryRuleFile
378entryRuleMetamodelSpecification 378entryRuleFile
379: 379:
380{ before(grammarAccess.getMetamodelSpecificationRule()); } 380{ before(grammarAccess.getFileRule()); }
381 ruleMetamodelSpecification 381 ruleFile
382{ after(grammarAccess.getMetamodelSpecificationRule()); } 382{ after(grammarAccess.getFileRule()); }
383 EOF 383 EOF
384; 384;
385 385
386// Rule MetamodelSpecification 386// Rule File
387ruleMetamodelSpecification 387ruleFile
388 @init { 388 @init {
389 int stackSize = keepStackSize(); 389 int stackSize = keepStackSize();
390 } 390 }
391 : 391 :
392 ( 392 (
393 { before(grammarAccess.getMetamodelSpecificationAccess().getGroup()); } 393 { before(grammarAccess.getFileAccess().getAlternatives()); }
394 (rule__MetamodelSpecification__Group__0) 394 (rule__File__Alternatives)
395 { after(grammarAccess.getMetamodelSpecificationAccess().getGroup()); } 395 { after(grammarAccess.getFileAccess().getAlternatives()); }
396 ) 396 )
397; 397;
398finally { 398finally {
399 restoreStackSize(stackSize); 399 restoreStackSize(stackSize);
400} 400}
401 401
402// Entry rule entryRuleMetamodelEntry 402// Entry rule entryRuleMetamodelSpecification
403entryRuleMetamodelEntry 403entryRuleMetamodelSpecification
404: 404:
405{ before(grammarAccess.getMetamodelEntryRule()); } 405{ before(grammarAccess.getMetamodelSpecificationRule()); }
406 ruleMetamodelEntry 406 ruleMetamodelSpecification
407{ after(grammarAccess.getMetamodelEntryRule()); } 407{ after(grammarAccess.getMetamodelSpecificationRule()); }
408 EOF 408 EOF
409; 409;
410 410
411// Rule MetamodelEntry 411// Rule MetamodelSpecification
412ruleMetamodelEntry 412ruleMetamodelSpecification
413 @init { 413 @init {
414 int stackSize = keepStackSize(); 414 int stackSize = keepStackSize();
415 } 415 }
416 : 416 :
417 ( 417 (
418 { before(grammarAccess.getMetamodelEntryAccess().getAlternatives()); } 418 { before(grammarAccess.getMetamodelSpecificationAccess().getGroup()); }
419 (rule__MetamodelEntry__Alternatives) 419 (rule__MetamodelSpecification__Group__0)
420 { after(grammarAccess.getMetamodelEntryAccess().getAlternatives()); } 420 { after(grammarAccess.getMetamodelSpecificationAccess().getGroup()); }
421 ) 421 )
422; 422;
423finally { 423finally {
424 restoreStackSize(stackSize); 424 restoreStackSize(stackSize);
425} 425}
426 426
427// Entry rule entryRuleAllPackageEntry 427// Entry rule entryRuleMetamodelEntry
428entryRuleAllPackageEntry 428entryRuleMetamodelEntry
429: 429:
430{ before(grammarAccess.getAllPackageEntryRule()); } 430{ before(grammarAccess.getMetamodelEntryRule()); }
431 ruleAllPackageEntry 431 ruleMetamodelEntry
432{ after(grammarAccess.getAllPackageEntryRule()); } 432{ after(grammarAccess.getMetamodelEntryRule()); }
433 EOF 433 EOF
434; 434;
435 435
436// Rule AllPackageEntry 436// Rule MetamodelEntry
437ruleAllPackageEntry 437ruleMetamodelEntry
438 @init { 438 @init {
439 int stackSize = keepStackSize(); 439 int stackSize = keepStackSize();
440 } 440 }
441 : 441 :
442 ( 442 (
443 { before(grammarAccess.getAllPackageEntryAccess().getGroup()); } 443 { before(grammarAccess.getMetamodelEntryAccess().getAlternatives()); }
444 (rule__AllPackageEntry__Group__0) 444 (rule__MetamodelEntry__Alternatives)
445 { after(grammarAccess.getAllPackageEntryAccess().getGroup()); } 445 { after(grammarAccess.getMetamodelEntryAccess().getAlternatives()); }
446 ) 446 )
447; 447;
448finally { 448finally {
449 restoreStackSize(stackSize); 449 restoreStackSize(stackSize);
450} 450}
451 451
452// Entry rule entryRuleMetamodelElement 452// Entry rule entryRuleAllPackageEntry
453entryRuleMetamodelElement 453entryRuleAllPackageEntry
454: 454:
455{ before(grammarAccess.getMetamodelElementRule()); } 455{ before(grammarAccess.getAllPackageEntryRule()); }
456 ruleMetamodelElement 456 ruleAllPackageEntry
457{ after(grammarAccess.getMetamodelElementRule()); } 457{ after(grammarAccess.getAllPackageEntryRule()); }
458 EOF 458 EOF
459; 459;
460 460
461// Rule MetamodelElement 461// Rule AllPackageEntry
462ruleMetamodelElement 462ruleAllPackageEntry
463 @init { 463 @init {
464 int stackSize = keepStackSize(); 464 int stackSize = keepStackSize();
465 } 465 }
466 : 466 :
467 ( 467 (
468 { before(grammarAccess.getMetamodelElementAccess().getGroup()); } 468 { before(grammarAccess.getAllPackageEntryAccess().getGroup()); }
469 (rule__MetamodelElement__Group__0) 469 (rule__AllPackageEntry__Group__0)
470 { after(grammarAccess.getMetamodelElementAccess().getGroup()); } 470 { after(grammarAccess.getAllPackageEntryAccess().getGroup()); }
471 ) 471 )
472; 472;
473finally { 473finally {
474 restoreStackSize(stackSize); 474 restoreStackSize(stackSize);
475} 475}
476 476
477// Entry rule entryRuleMetamodelDeclaration 477// Entry rule entryRuleMetamodelElement
478entryRuleMetamodelDeclaration 478entryRuleMetamodelElement
479: 479:
480{ before(grammarAccess.getMetamodelDeclarationRule()); } 480{ before(grammarAccess.getMetamodelElementRule()); }
481 ruleMetamodelDeclaration 481 ruleMetamodelElement
482{ after(grammarAccess.getMetamodelDeclarationRule()); } 482{ after(grammarAccess.getMetamodelElementRule()); }
483 EOF 483 EOF
484; 484;
485 485
486// Rule MetamodelDeclaration 486// Rule MetamodelElement
487ruleMetamodelDeclaration 487ruleMetamodelElement
488 @init { 488 @init {
489 int stackSize = keepStackSize(); 489 int stackSize = keepStackSize();
490 } 490 }
491 : 491 :
492 ( 492 (
493 { before(grammarAccess.getMetamodelDeclarationAccess().getGroup()); } 493 { before(grammarAccess.getMetamodelElementAccess().getGroup()); }
494 (rule__MetamodelDeclaration__Group__0) 494 (rule__MetamodelElement__Group__0)
495 { after(grammarAccess.getMetamodelDeclarationAccess().getGroup()); } 495 { after(grammarAccess.getMetamodelElementAccess().getGroup()); }
496 ) 496 )
497; 497;
498finally { 498finally {
499 restoreStackSize(stackSize); 499 restoreStackSize(stackSize);
500} 500}
501 501
502// Entry rule entryRuleMetamodelReference 502// Entry rule entryRuleMetamodelDeclaration
503entryRuleMetamodelReference 503entryRuleMetamodelDeclaration
504: 504:
505{ before(grammarAccess.getMetamodelReferenceRule()); } 505{ before(grammarAccess.getMetamodelDeclarationRule()); }
506 ruleMetamodelReference 506 ruleMetamodelDeclaration
507{ after(grammarAccess.getMetamodelReferenceRule()); } 507{ after(grammarAccess.getMetamodelDeclarationRule()); }
508 EOF 508 EOF
509; 509;
510 510
511// Rule MetamodelReference 511// Rule MetamodelDeclaration
512ruleMetamodelReference 512ruleMetamodelDeclaration
513 @init { 513 @init {
514 int stackSize = keepStackSize(); 514 int stackSize = keepStackSize();
515 } 515 }
516 : 516 :
517 ( 517 (
518 { before(grammarAccess.getMetamodelReferenceAccess().getReferredAssignment()); } 518 { before(grammarAccess.getMetamodelDeclarationAccess().getGroup()); }
519 (rule__MetamodelReference__ReferredAssignment) 519 (rule__MetamodelDeclaration__Group__0)
520 { after(grammarAccess.getMetamodelReferenceAccess().getReferredAssignment()); } 520 { after(grammarAccess.getMetamodelDeclarationAccess().getGroup()); }
521 ) 521 )
522; 522;
523finally { 523finally {
524 restoreStackSize(stackSize); 524 restoreStackSize(stackSize);
525} 525}
526 526
527// Entry rule entryRuleMetamodel 527// Entry rule entryRuleMetamodelReference
528entryRuleMetamodel 528entryRuleMetamodelReference
529: 529:
530{ before(grammarAccess.getMetamodelRule()); } 530{ before(grammarAccess.getMetamodelReferenceRule()); }
531 ruleMetamodel 531 ruleMetamodelReference
532{ after(grammarAccess.getMetamodelRule()); } 532{ after(grammarAccess.getMetamodelReferenceRule()); }
533 EOF 533 EOF
534; 534;
535 535
536// Rule Metamodel 536// Rule MetamodelReference
537ruleMetamodel 537ruleMetamodelReference
538 @init { 538 @init {
539 int stackSize = keepStackSize(); 539 int stackSize = keepStackSize();
540 } 540 }
541 : 541 :
542 ( 542 (
543 { before(grammarAccess.getMetamodelAccess().getAlternatives()); } 543 { before(grammarAccess.getMetamodelReferenceAccess().getReferredAssignment()); }
544 (rule__Metamodel__Alternatives) 544 (rule__MetamodelReference__ReferredAssignment)
545 { after(grammarAccess.getMetamodelAccess().getAlternatives()); } 545 { after(grammarAccess.getMetamodelReferenceAccess().getReferredAssignment()); }
546 ) 546 )
547; 547;
548finally { 548finally {
549 restoreStackSize(stackSize); 549 restoreStackSize(stackSize);
550} 550}
551 551
552// Entry rule entryRulePartialModelSpecification 552// Entry rule entryRuleMetamodel
553entryRulePartialModelSpecification 553entryRuleMetamodel
554: 554:
555{ before(grammarAccess.getPartialModelSpecificationRule()); } 555{ before(grammarAccess.getMetamodelRule()); }
556 rulePartialModelSpecification 556 ruleMetamodel
557{ after(grammarAccess.getPartialModelSpecificationRule()); } 557{ after(grammarAccess.getMetamodelRule()); }
558 EOF 558 EOF
559; 559;
560 560
561// Rule PartialModelSpecification 561// Rule Metamodel
562rulePartialModelSpecification 562ruleMetamodel
563 @init { 563 @init {
564 int stackSize = keepStackSize(); 564 int stackSize = keepStackSize();
565 } 565 }
566 : 566 :
567 ( 567 (
568 { before(grammarAccess.getPartialModelSpecificationAccess().getGroup()); } 568 { before(grammarAccess.getMetamodelAccess().getAlternatives()); }
569 (rule__PartialModelSpecification__Group__0) 569 (rule__Metamodel__Alternatives)
570 { after(grammarAccess.getPartialModelSpecificationAccess().getGroup()); } 570 { after(grammarAccess.getMetamodelAccess().getAlternatives()); }
571 ) 571 )
572; 572;
573finally { 573finally {
574 restoreStackSize(stackSize); 574 restoreStackSize(stackSize);
575} 575}
576 576
577// Entry rule entryRulePartialModelEntry 577// Entry rule entryRulePartialModelSpecification
578entryRulePartialModelEntry 578entryRulePartialModelSpecification
579: 579:
580{ before(grammarAccess.getPartialModelEntryRule()); } 580{ before(grammarAccess.getPartialModelSpecificationRule()); }
581 rulePartialModelEntry 581 rulePartialModelSpecification
582{ after(grammarAccess.getPartialModelEntryRule()); } 582{ after(grammarAccess.getPartialModelSpecificationRule()); }
583 EOF 583 EOF
584; 584;
585 585
586// Rule PartialModelEntry 586// Rule PartialModelSpecification
587rulePartialModelEntry 587rulePartialModelSpecification
588 @init { 588 @init {
589 int stackSize = keepStackSize(); 589 int stackSize = keepStackSize();
590 } 590 }
591 : 591 :
592 ( 592 (
593 { before(grammarAccess.getPartialModelEntryAccess().getAlternatives()); } 593 { before(grammarAccess.getPartialModelSpecificationAccess().getGroup()); }
594 (rule__PartialModelEntry__Alternatives) 594 (rule__PartialModelSpecification__Group__0)
595 { after(grammarAccess.getPartialModelEntryAccess().getAlternatives()); } 595 { after(grammarAccess.getPartialModelSpecificationAccess().getGroup()); }
596 ) 596 )
597; 597;
598finally { 598finally {
599 restoreStackSize(stackSize); 599 restoreStackSize(stackSize);
600} 600}
601 601
602// Entry rule entryRuleModelEntry 602// Entry rule entryRulePartialModelEntry
603entryRuleModelEntry 603entryRulePartialModelEntry
604: 604:
605{ before(grammarAccess.getModelEntryRule()); } 605{ before(grammarAccess.getPartialModelEntryRule()); }
606 ruleModelEntry 606 rulePartialModelEntry
607{ after(grammarAccess.getModelEntryRule()); } 607{ after(grammarAccess.getPartialModelEntryRule()); }
608 EOF 608 EOF
609; 609;
610 610
611// Rule ModelEntry 611// Rule PartialModelEntry
612ruleModelEntry 612rulePartialModelEntry
613 @init { 613 @init {
614 int stackSize = keepStackSize(); 614 int stackSize = keepStackSize();
615 } 615 }
616 : 616 :
617 ( 617 (
618 { before(grammarAccess.getModelEntryAccess().getPathAssignment()); } 618 { before(grammarAccess.getPartialModelEntryAccess().getAlternatives()); }
619 (rule__ModelEntry__PathAssignment) 619 (rule__PartialModelEntry__Alternatives)
620 { after(grammarAccess.getModelEntryAccess().getPathAssignment()); } 620 { after(grammarAccess.getPartialModelEntryAccess().getAlternatives()); }
621 ) 621 )
622; 622;
623finally { 623finally {
624 restoreStackSize(stackSize); 624 restoreStackSize(stackSize);
625} 625}
626 626
627// Entry rule entryRuleFolderEntry 627// Entry rule entryRuleModelEntry
628entryRuleFolderEntry 628entryRuleModelEntry
629: 629:
630{ before(grammarAccess.getFolderEntryRule()); } 630{ before(grammarAccess.getModelEntryRule()); }
631 ruleFolderEntry 631 ruleModelEntry
632{ after(grammarAccess.getFolderEntryRule()); } 632{ after(grammarAccess.getModelEntryRule()); }
633 EOF 633 EOF
634; 634;
635 635
636// Rule FolderEntry 636// Rule ModelEntry
637ruleFolderEntry 637ruleModelEntry
638 @init { 638 @init {
639 int stackSize = keepStackSize(); 639 int stackSize = keepStackSize();
640 } 640 }
641 : 641 :
642 ( 642 (
643 { before(grammarAccess.getFolderEntryAccess().getGroup()); } 643 { before(grammarAccess.getModelEntryAccess().getPathAssignment()); }
644 (rule__FolderEntry__Group__0) 644 (rule__ModelEntry__PathAssignment)
645 { after(grammarAccess.getFolderEntryAccess().getGroup()); } 645 { after(grammarAccess.getModelEntryAccess().getPathAssignment()); }
646 ) 646 )
647; 647;
648finally { 648finally {
649 restoreStackSize(stackSize); 649 restoreStackSize(stackSize);
650} 650}
651 651
652// Entry rule entryRulePartialModelDeclaration 652// Entry rule entryRuleFolderEntry
653entryRulePartialModelDeclaration 653entryRuleFolderEntry
654: 654:
655{ before(grammarAccess.getPartialModelDeclarationRule()); } 655{ before(grammarAccess.getFolderEntryRule()); }
656 rulePartialModelDeclaration 656 ruleFolderEntry
657{ after(grammarAccess.getPartialModelDeclarationRule()); } 657{ after(grammarAccess.getFolderEntryRule()); }
658 EOF 658 EOF
659; 659;
660 660
661// Rule PartialModelDeclaration 661// Rule FolderEntry
662rulePartialModelDeclaration 662ruleFolderEntry
663 @init { 663 @init {
664 int stackSize = keepStackSize(); 664 int stackSize = keepStackSize();
665 } 665 }
666 : 666 :
667 ( 667 (
668 { before(grammarAccess.getPartialModelDeclarationAccess().getGroup()); } 668 { before(grammarAccess.getFolderEntryAccess().getGroup()); }
669 (rule__PartialModelDeclaration__Group__0) 669 (rule__FolderEntry__Group__0)
670 { after(grammarAccess.getPartialModelDeclarationAccess().getGroup()); } 670 { after(grammarAccess.getFolderEntryAccess().getGroup()); }
671 ) 671 )
672; 672;
673finally { 673finally {
674 restoreStackSize(stackSize); 674 restoreStackSize(stackSize);
675} 675}
676 676
677// Entry rule entryRulePartialModelReference 677// Entry rule entryRulePartialModelDeclaration
678entryRulePartialModelReference 678entryRulePartialModelDeclaration
679: 679:
680{ before(grammarAccess.getPartialModelReferenceRule()); } 680{ before(grammarAccess.getPartialModelDeclarationRule()); }
681 rulePartialModelReference 681 rulePartialModelDeclaration
682{ after(grammarAccess.getPartialModelReferenceRule()); } 682{ after(grammarAccess.getPartialModelDeclarationRule()); }
683 EOF 683 EOF
684; 684;
685 685
686// Rule PartialModelReference 686// Rule PartialModelDeclaration
687rulePartialModelReference 687rulePartialModelDeclaration
688 @init { 688 @init {
689 int stackSize = keepStackSize(); 689 int stackSize = keepStackSize();
690 } 690 }
691 : 691 :
692 ( 692 (
693 { before(grammarAccess.getPartialModelReferenceAccess().getReferredAssignment()); } 693 { before(grammarAccess.getPartialModelDeclarationAccess().getGroup()); }
694 (rule__PartialModelReference__ReferredAssignment) 694 (rule__PartialModelDeclaration__Group__0)
695 { after(grammarAccess.getPartialModelReferenceAccess().getReferredAssignment()); } 695 { after(grammarAccess.getPartialModelDeclarationAccess().getGroup()); }
696 ) 696 )
697; 697;
698finally { 698finally {
699 restoreStackSize(stackSize); 699 restoreStackSize(stackSize);
700} 700}
701 701
702// Entry rule entryRulePartialModel 702// Entry rule entryRulePartialModelReference
703entryRulePartialModel 703entryRulePartialModelReference
704: 704:
705{ before(grammarAccess.getPartialModelRule()); } 705{ before(grammarAccess.getPartialModelReferenceRule()); }
706 rulePartialModel 706 rulePartialModelReference
707{ after(grammarAccess.getPartialModelRule()); } 707{ after(grammarAccess.getPartialModelReferenceRule()); }
708 EOF 708 EOF
709; 709;
710 710
711// Rule PartialModel 711// Rule PartialModelReference
712rulePartialModel 712rulePartialModelReference
713 @init { 713 @init {
714 int stackSize = keepStackSize(); 714 int stackSize = keepStackSize();
715 } 715 }
716 : 716 :
717 ( 717 (
718 { before(grammarAccess.getPartialModelAccess().getAlternatives()); } 718 { before(grammarAccess.getPartialModelReferenceAccess().getReferredAssignment()); }
719 (rule__PartialModel__Alternatives) 719 (rule__PartialModelReference__ReferredAssignment)
720 { after(grammarAccess.getPartialModelAccess().getAlternatives()); } 720 { after(grammarAccess.getPartialModelReferenceAccess().getReferredAssignment()); }
721 ) 721 )
722; 722;
723finally { 723finally {
724 restoreStackSize(stackSize); 724 restoreStackSize(stackSize);
725} 725}
726 726
727// Entry rule entryRulePatternSpecification 727// Entry rule entryRulePartialModel
728entryRulePatternSpecification 728entryRulePartialModel
729: 729:
730{ before(grammarAccess.getPatternSpecificationRule()); } 730{ before(grammarAccess.getPartialModelRule()); }
731 rulePatternSpecification 731 rulePartialModel
732{ after(grammarAccess.getPatternSpecificationRule()); } 732{ after(grammarAccess.getPartialModelRule()); }
733 EOF 733 EOF
734; 734;
735 735
736// Rule PatternSpecification 736// Rule PartialModel
737rulePatternSpecification 737rulePartialModel
738 @init { 738 @init {
739 int stackSize = keepStackSize(); 739 int stackSize = keepStackSize();
740 } 740 }
741 : 741 :
742 ( 742 (
743 { before(grammarAccess.getPatternSpecificationAccess().getGroup()); } 743 { before(grammarAccess.getPartialModelAccess().getAlternatives()); }
744 (rule__PatternSpecification__Group__0) 744 (rule__PartialModel__Alternatives)
745 { after(grammarAccess.getPatternSpecificationAccess().getGroup()); } 745 { after(grammarAccess.getPartialModelAccess().getAlternatives()); }
746 ) 746 )
747; 747;
748finally { 748finally {
749 restoreStackSize(stackSize); 749 restoreStackSize(stackSize);
750} 750}
751 751
752// Entry rule entryRulePatternEntry 752// Entry rule entryRulePatternSpecification
753entryRulePatternEntry 753entryRulePatternSpecification
754: 754:
755{ before(grammarAccess.getPatternEntryRule()); } 755{ before(grammarAccess.getPatternSpecificationRule()); }
756 rulePatternEntry 756 rulePatternSpecification
757{ after(grammarAccess.getPatternEntryRule()); } 757{ after(grammarAccess.getPatternSpecificationRule()); }
758 EOF 758 EOF
759; 759;
760 760
761// Rule PatternEntry 761// Rule PatternSpecification
762rulePatternEntry 762rulePatternSpecification
763 @init { 763 @init {
764 int stackSize = keepStackSize(); 764 int stackSize = keepStackSize();
765 } 765 }
766 : 766 :
767 ( 767 (
768 { before(grammarAccess.getPatternEntryAccess().getAlternatives()); } 768 { before(grammarAccess.getPatternSpecificationAccess().getGroup()); }
769 (rule__PatternEntry__Alternatives) 769 (rule__PatternSpecification__Group__0)
770 { after(grammarAccess.getPatternEntryAccess().getAlternatives()); } 770 { after(grammarAccess.getPatternSpecificationAccess().getGroup()); }
771 ) 771 )
772; 772;
773finally { 773finally {
774 restoreStackSize(stackSize); 774 restoreStackSize(stackSize);
775} 775}
776 776
777// Entry rule entryRuleAllPatternEntry 777// Entry rule entryRulePatternEntry
778entryRuleAllPatternEntry 778entryRulePatternEntry
779: 779:
780{ before(grammarAccess.getAllPatternEntryRule()); } 780{ before(grammarAccess.getPatternEntryRule()); }
781 ruleAllPatternEntry 781 rulePatternEntry
782{ after(grammarAccess.getAllPatternEntryRule()); } 782{ after(grammarAccess.getPatternEntryRule()); }
783 EOF 783 EOF
784; 784;
785 785
786// Rule AllPatternEntry 786// Rule PatternEntry
787ruleAllPatternEntry 787rulePatternEntry
788 @init { 788 @init {
789 int stackSize = keepStackSize(); 789 int stackSize = keepStackSize();
790 } 790 }
791 : 791 :
792 ( 792 (
793 { before(grammarAccess.getAllPatternEntryAccess().getGroup()); } 793 { before(grammarAccess.getPatternEntryAccess().getAlternatives()); }
794 (rule__AllPatternEntry__Group__0) 794 (rule__PatternEntry__Alternatives)
795 { after(grammarAccess.getAllPatternEntryAccess().getGroup()); } 795 { after(grammarAccess.getPatternEntryAccess().getAlternatives()); }
796 ) 796 )
797; 797;
798finally { 798finally {
799 restoreStackSize(stackSize); 799 restoreStackSize(stackSize);
800} 800}
801 801
802// Entry rule entryRulePatternElement 802// Entry rule entryRuleAllPatternEntry
803entryRulePatternElement 803entryRuleAllPatternEntry
804: 804:
805{ before(grammarAccess.getPatternElementRule()); } 805{ before(grammarAccess.getAllPatternEntryRule()); }
806 rulePatternElement 806 ruleAllPatternEntry
807{ after(grammarAccess.getPatternElementRule()); } 807{ after(grammarAccess.getAllPatternEntryRule()); }
808 EOF 808 EOF
809; 809;
810 810
811// Rule PatternElement 811// Rule AllPatternEntry
812rulePatternElement 812ruleAllPatternEntry
813 @init { 813 @init {
814 int stackSize = keepStackSize(); 814 int stackSize = keepStackSize();
815 } 815 }
816 : 816 :
817 ( 817 (
818 { before(grammarAccess.getPatternElementAccess().getGroup()); } 818 { before(grammarAccess.getAllPatternEntryAccess().getGroup()); }
819 (rule__PatternElement__Group__0) 819 (rule__AllPatternEntry__Group__0)
820 { after(grammarAccess.getPatternElementAccess().getGroup()); } 820 { after(grammarAccess.getAllPatternEntryAccess().getGroup()); }
821 ) 821 )
822; 822;
823finally { 823finally {
824 restoreStackSize(stackSize); 824 restoreStackSize(stackSize);
825} 825}
826 826
827// Entry rule entryRuleGraphPatternDeclaration 827// Entry rule entryRulePatternElement
828entryRuleGraphPatternDeclaration 828entryRulePatternElement
829: 829:
830{ before(grammarAccess.getGraphPatternDeclarationRule()); } 830{ before(grammarAccess.getPatternElementRule()); }
831 ruleGraphPatternDeclaration 831 rulePatternElement
832{ after(grammarAccess.getGraphPatternDeclarationRule()); } 832{ after(grammarAccess.getPatternElementRule()); }
833 EOF 833 EOF
834; 834;
835 835
836// Rule GraphPatternDeclaration 836// Rule PatternElement
837ruleGraphPatternDeclaration 837rulePatternElement
838 @init { 838 @init {
839 int stackSize = keepStackSize(); 839 int stackSize = keepStackSize();
840 } 840 }
841 : 841 :
842 ( 842 (
843 { before(grammarAccess.getGraphPatternDeclarationAccess().getGroup()); } 843 { before(grammarAccess.getPatternElementAccess().getGroup()); }
844 (rule__GraphPatternDeclaration__Group__0) 844 (rule__PatternElement__Group__0)
845 { after(grammarAccess.getGraphPatternDeclarationAccess().getGroup()); } 845 { after(grammarAccess.getPatternElementAccess().getGroup()); }
846 ) 846 )
847; 847;
848finally { 848finally {
849 restoreStackSize(stackSize); 849 restoreStackSize(stackSize);
850} 850}
851 851
852// Entry rule entryRuleGraphPatternReference 852// Entry rule entryRuleGraphPatternDeclaration
853entryRuleGraphPatternReference 853entryRuleGraphPatternDeclaration
854: 854:
855{ before(grammarAccess.getGraphPatternReferenceRule()); } 855{ before(grammarAccess.getGraphPatternDeclarationRule()); }
856 ruleGraphPatternReference 856 ruleGraphPatternDeclaration
857{ after(grammarAccess.getGraphPatternReferenceRule()); } 857{ after(grammarAccess.getGraphPatternDeclarationRule()); }
858 EOF 858 EOF
859; 859;
860 860
861// Rule GraphPatternReference 861// Rule GraphPatternDeclaration
862ruleGraphPatternReference 862ruleGraphPatternDeclaration
863 @init { 863 @init {
864 int stackSize = keepStackSize(); 864 int stackSize = keepStackSize();
865 } 865 }
866 : 866 :
867 ( 867 (
868 { before(grammarAccess.getGraphPatternReferenceAccess().getReferredAssignment()); } 868 { before(grammarAccess.getGraphPatternDeclarationAccess().getGroup()); }
869 (rule__GraphPatternReference__ReferredAssignment) 869 (rule__GraphPatternDeclaration__Group__0)
870 { after(grammarAccess.getGraphPatternReferenceAccess().getReferredAssignment()); } 870 { after(grammarAccess.getGraphPatternDeclarationAccess().getGroup()); }
871 ) 871 )
872; 872;
873finally { 873finally {
874 restoreStackSize(stackSize); 874 restoreStackSize(stackSize);
875} 875}
876 876
877// Entry rule entryRuleGraphPattern 877// Entry rule entryRuleGraphPatternReference
878entryRuleGraphPattern 878entryRuleGraphPatternReference
879: 879:
880{ before(grammarAccess.getGraphPatternRule()); } 880{ before(grammarAccess.getGraphPatternReferenceRule()); }
881 ruleGraphPattern 881 ruleGraphPatternReference
882{ after(grammarAccess.getGraphPatternRule()); } 882{ after(grammarAccess.getGraphPatternReferenceRule()); }
883 EOF 883 EOF
884; 884;
885 885
886// Rule GraphPattern 886// Rule GraphPatternReference
887ruleGraphPattern 887ruleGraphPatternReference
888 @init { 888 @init {
889 int stackSize = keepStackSize(); 889 int stackSize = keepStackSize();
890 } 890 }
891 : 891 :
892 ( 892 (
893 { before(grammarAccess.getGraphPatternAccess().getAlternatives()); } 893 { before(grammarAccess.getGraphPatternReferenceAccess().getReferredAssignment()); }
894 (rule__GraphPattern__Alternatives) 894 (rule__GraphPatternReference__ReferredAssignment)
895 { after(grammarAccess.getGraphPatternAccess().getAlternatives()); } 895 { after(grammarAccess.getGraphPatternReferenceAccess().getReferredAssignment()); }
896 ) 896 )
897; 897;
898finally { 898finally {
899 restoreStackSize(stackSize); 899 restoreStackSize(stackSize);
900} 900}
901 901
902// Entry rule entryRuleConfigSpecification 902// Entry rule entryRuleGraphPattern
903entryRuleConfigSpecification 903entryRuleGraphPattern
904: 904:
905{ before(grammarAccess.getConfigSpecificationRule()); } 905{ before(grammarAccess.getGraphPatternRule()); }
906 ruleConfigSpecification 906 ruleGraphPattern
907{ after(grammarAccess.getConfigSpecificationRule()); } 907{ after(grammarAccess.getGraphPatternRule()); }
908 EOF 908 EOF
909; 909;
910 910
911// Rule ConfigSpecification 911// Rule GraphPattern
912ruleConfigSpecification 912ruleGraphPattern
913 @init { 913 @init {
914 int stackSize = keepStackSize(); 914 int stackSize = keepStackSize();
915 } 915 }
916 : 916 :
917 ( 917 (
918 { before(grammarAccess.getConfigSpecificationAccess().getGroup()); } 918 { before(grammarAccess.getGraphPatternAccess().getAlternatives()); }
919 (rule__ConfigSpecification__Group__0) 919 (rule__GraphPattern__Alternatives)
920 { after(grammarAccess.getConfigSpecificationAccess().getGroup()); } 920 { after(grammarAccess.getGraphPatternAccess().getAlternatives()); }
921 ) 921 )
922; 922;
923finally { 923finally {
924 restoreStackSize(stackSize); 924 restoreStackSize(stackSize);
925} 925}
926 926
927// Entry rule entryRuleConfigDeclaration 927// Entry rule entryRuleObjectiveSpecification
928entryRuleConfigDeclaration 928entryRuleObjectiveSpecification
929: 929:
930{ before(grammarAccess.getConfigDeclarationRule()); } 930{ before(grammarAccess.getObjectiveSpecificationRule()); }
931 ruleConfigDeclaration 931 ruleObjectiveSpecification
932{ after(grammarAccess.getConfigDeclarationRule()); } 932{ after(grammarAccess.getObjectiveSpecificationRule()); }
933 EOF 933 EOF
934; 934;
935 935
936// Rule ConfigDeclaration 936// Rule ObjectiveSpecification
937ruleConfigDeclaration 937ruleObjectiveSpecification
938 @init { 938 @init {
939 int stackSize = keepStackSize(); 939 int stackSize = keepStackSize();
940 } 940 }
941 : 941 :
942 ( 942 (
943 { before(grammarAccess.getConfigDeclarationAccess().getGroup()); } 943 { before(grammarAccess.getObjectiveSpecificationAccess().getGroup()); }
944 (rule__ConfigDeclaration__Group__0) 944 (rule__ObjectiveSpecification__Group__0)
945 { after(grammarAccess.getConfigDeclarationAccess().getGroup()); } 945 { after(grammarAccess.getObjectiveSpecificationAccess().getGroup()); }
946 ) 946 )
947; 947;
948finally { 948finally {
949 restoreStackSize(stackSize); 949 restoreStackSize(stackSize);
950} 950}
951 951
952// Entry rule entryRuleConfigEntry 952// Entry rule entryRuleObjectiveEntry
953entryRuleConfigEntry 953entryRuleObjectiveEntry
954: 954:
955{ before(grammarAccess.getConfigEntryRule()); } 955{ before(grammarAccess.getObjectiveEntryRule()); }
956 ruleConfigEntry 956 ruleObjectiveEntry
957{ after(grammarAccess.getConfigEntryRule()); } 957{ after(grammarAccess.getObjectiveEntryRule()); }
958 EOF 958 EOF
959; 959;
960 960
961// Rule ConfigEntry 961// Rule ObjectiveEntry
962ruleConfigEntry 962ruleObjectiveEntry
963 @init { 963 @init {
964 int stackSize = keepStackSize(); 964 int stackSize = keepStackSize();
965 } 965 }
966 : 966 :
967 ( 967 (
968 { before(grammarAccess.getConfigEntryAccess().getAlternatives()); } 968 { before(grammarAccess.getObjectiveEntryAccess().getAlternatives()); }
969 (rule__ConfigEntry__Alternatives) 969 (rule__ObjectiveEntry__Alternatives)
970 { after(grammarAccess.getConfigEntryAccess().getAlternatives()); } 970 { after(grammarAccess.getObjectiveEntryAccess().getAlternatives()); }
971 ) 971 )
972; 972;
973finally { 973finally {
974 restoreStackSize(stackSize); 974 restoreStackSize(stackSize);
975} 975}
976 976
977// Entry rule entryRuleDocumentationEntry 977// Entry rule entryRuleOptimizationEntry
978entryRuleDocumentationEntry 978entryRuleOptimizationEntry
979: 979:
980{ before(grammarAccess.getDocumentationEntryRule()); } 980{ before(grammarAccess.getOptimizationEntryRule()); }
981 ruleDocumentationEntry 981 ruleOptimizationEntry
982{ after(grammarAccess.getDocumentationEntryRule()); } 982{ after(grammarAccess.getOptimizationEntryRule()); }
983 EOF 983 EOF
984; 984;
985 985
986// Rule DocumentationEntry 986// Rule OptimizationEntry
987ruleDocumentationEntry 987ruleOptimizationEntry
988 @init { 988 @init {
989 int stackSize = keepStackSize(); 989 int stackSize = keepStackSize();
990 } 990 }
991 : 991 :
992 ( 992 (
993 { before(grammarAccess.getDocumentationEntryAccess().getGroup()); } 993 { before(grammarAccess.getOptimizationEntryAccess().getGroup()); }
994 (rule__DocumentationEntry__Group__0) 994 (rule__OptimizationEntry__Group__0)
995 { after(grammarAccess.getDocumentationEntryAccess().getGroup()); } 995 { after(grammarAccess.getOptimizationEntryAccess().getGroup()); }
996 ) 996 )
997; 997;
998finally { 998finally {
999 restoreStackSize(stackSize); 999 restoreStackSize(stackSize);
1000} 1000}
1001 1001
1002// Entry rule entryRuleRuntimeEntry 1002// Entry rule entryRuleThresholdEntry
1003entryRuleRuntimeEntry 1003entryRuleThresholdEntry
1004: 1004:
1005{ before(grammarAccess.getRuntimeEntryRule()); } 1005{ before(grammarAccess.getThresholdEntryRule()); }
1006 ruleRuntimeEntry 1006 ruleThresholdEntry
1007{ after(grammarAccess.getRuntimeEntryRule()); } 1007{ after(grammarAccess.getThresholdEntryRule()); }
1008 EOF 1008 EOF
1009; 1009;
1010 1010
1011// Rule RuntimeEntry 1011// Rule ThresholdEntry
1012ruleRuntimeEntry 1012ruleThresholdEntry
1013 @init { 1013 @init {
1014 int stackSize = keepStackSize(); 1014 int stackSize = keepStackSize();
1015 } 1015 }
1016 : 1016 :
1017 ( 1017 (
1018 { before(grammarAccess.getRuntimeEntryAccess().getGroup()); } 1018 { before(grammarAccess.getThresholdEntryAccess().getGroup()); }
1019 (rule__RuntimeEntry__Group__0) 1019 (rule__ThresholdEntry__Group__0)
1020 { after(grammarAccess.getRuntimeEntryAccess().getGroup()); } 1020 { after(grammarAccess.getThresholdEntryAccess().getGroup()); }
1021 ) 1021 )
1022; 1022;
1023finally { 1023finally {
1024 restoreStackSize(stackSize); 1024 restoreStackSize(stackSize);
1025} 1025}
1026 1026
1027// Entry rule entryRuleMemoryEntry 1027// Entry rule entryRuleObjectiveFunction
1028entryRuleMemoryEntry 1028entryRuleObjectiveFunction
1029: 1029:
1030{ before(grammarAccess.getMemoryEntryRule()); } 1030{ before(grammarAccess.getObjectiveFunctionRule()); }
1031 ruleMemoryEntry 1031 ruleObjectiveFunction
1032{ after(grammarAccess.getMemoryEntryRule()); } 1032{ after(grammarAccess.getObjectiveFunctionRule()); }
1033 EOF 1033 EOF
1034; 1034;
1035 1035
1036// Rule MemoryEntry 1036// Rule ObjectiveFunction
1037ruleMemoryEntry 1037ruleObjectiveFunction
1038 @init { 1038 @init {
1039 int stackSize = keepStackSize(); 1039 int stackSize = keepStackSize();
1040 } 1040 }
1041 : 1041 :
1042 ( 1042 (
1043 { before(grammarAccess.getMemoryEntryAccess().getGroup()); } 1043 { before(grammarAccess.getObjectiveFunctionAccess().getReliabiltiyFunctionParserRuleCall()); }
1044 (rule__MemoryEntry__Group__0) 1044 ruleReliabiltiyFunction
1045 { after(grammarAccess.getMemoryEntryAccess().getGroup()); } 1045 { after(grammarAccess.getObjectiveFunctionAccess().getReliabiltiyFunctionParserRuleCall()); }
1046 ) 1046 )
1047; 1047;
1048finally { 1048finally {
1049 restoreStackSize(stackSize); 1049 restoreStackSize(stackSize);
1050} 1050}
1051 1051
1052// Entry rule entryRuleCustomEntry 1052// Entry rule entryRuleReliabiltiyFunction
1053entryRuleCustomEntry 1053entryRuleReliabiltiyFunction
1054: 1054:
1055{ before(grammarAccess.getCustomEntryRule()); } 1055{ before(grammarAccess.getReliabiltiyFunctionRule()); }
1056 ruleCustomEntry 1056 ruleReliabiltiyFunction
1057{ after(grammarAccess.getCustomEntryRule()); } 1057{ after(grammarAccess.getReliabiltiyFunctionRule()); }
1058 EOF 1058 EOF
1059; 1059;
1060 1060
1061// Rule CustomEntry 1061// Rule ReliabiltiyFunction
1062ruleCustomEntry 1062ruleReliabiltiyFunction
1063 @init { 1063 @init {
1064 int stackSize = keepStackSize(); 1064 int stackSize = keepStackSize();
1065 } 1065 }
1066 : 1066 :
1067 ( 1067 (
1068 { before(grammarAccess.getCustomEntryAccess().getGroup()); } 1068 { before(grammarAccess.getReliabiltiyFunctionAccess().getGroup()); }
1069 (rule__CustomEntry__Group__0) 1069 (rule__ReliabiltiyFunction__Group__0)
1070 { after(grammarAccess.getCustomEntryAccess().getGroup()); } 1070 { after(grammarAccess.getReliabiltiyFunctionAccess().getGroup()); }
1071 ) 1071 )
1072; 1072;
1073finally { 1073finally {
1074 restoreStackSize(stackSize); 1074 restoreStackSize(stackSize);
1075} 1075}
1076 1076
1077// Entry rule entryRuleConfigReference 1077// Entry rule entryRuleObjectiveDeclaration
1078entryRuleConfigReference 1078entryRuleObjectiveDeclaration
1079: 1079:
1080{ before(grammarAccess.getConfigReferenceRule()); } 1080{ before(grammarAccess.getObjectiveDeclarationRule()); }
1081 ruleConfigReference 1081 ruleObjectiveDeclaration
1082{ after(grammarAccess.getConfigReferenceRule()); } 1082{ after(grammarAccess.getObjectiveDeclarationRule()); }
1083 EOF 1083 EOF
1084; 1084;
1085 1085
1086// Rule ConfigReference 1086// Rule ObjectiveDeclaration
1087ruleConfigReference 1087ruleObjectiveDeclaration
1088 @init { 1088 @init {
1089 int stackSize = keepStackSize(); 1089 int stackSize = keepStackSize();
1090 } 1090 }
1091 : 1091 :
1092 ( 1092 (
1093 { before(grammarAccess.getConfigReferenceAccess().getConfigAssignment()); } 1093 { before(grammarAccess.getObjectiveDeclarationAccess().getGroup()); }
1094 (rule__ConfigReference__ConfigAssignment) 1094 (rule__ObjectiveDeclaration__Group__0)
1095 { after(grammarAccess.getConfigReferenceAccess().getConfigAssignment()); } 1095 { after(grammarAccess.getObjectiveDeclarationAccess().getGroup()); }
1096 ) 1096 )
1097; 1097;
1098finally { 1098finally {
1099 restoreStackSize(stackSize); 1099 restoreStackSize(stackSize);
1100} 1100}
1101 1101
1102// Entry rule entryRuleConfig 1102// Entry rule entryRuleObjectiveReference
1103entryRuleConfig 1103entryRuleObjectiveReference
1104: 1104:
1105{ before(grammarAccess.getConfigRule()); } 1105{ before(grammarAccess.getObjectiveReferenceRule()); }
1106 ruleConfig 1106 ruleObjectiveReference
1107{ after(grammarAccess.getConfigRule()); } 1107{ after(grammarAccess.getObjectiveReferenceRule()); }
1108 EOF 1108 EOF
1109; 1109;
1110 1110
1111// Rule Config 1111// Rule ObjectiveReference
1112ruleConfig 1112ruleObjectiveReference
1113 @init { 1113 @init {
1114 int stackSize = keepStackSize(); 1114 int stackSize = keepStackSize();
1115 } 1115 }
1116 : 1116 :
1117 ( 1117 (
1118 { before(grammarAccess.getConfigAccess().getAlternatives()); } 1118 { before(grammarAccess.getObjectiveReferenceAccess().getReferredAssignment()); }
1119 (rule__Config__Alternatives) 1119 (rule__ObjectiveReference__ReferredAssignment)
1120 { after(grammarAccess.getConfigAccess().getAlternatives()); } 1120 { after(grammarAccess.getObjectiveReferenceAccess().getReferredAssignment()); }
1121 ) 1121 )
1122; 1122;
1123finally { 1123finally {
1124 restoreStackSize(stackSize); 1124 restoreStackSize(stackSize);
1125} 1125}
1126 1126
1127// Entry rule entryRuleScopeSpecification 1127// Entry rule entryRuleObjective
1128entryRuleScopeSpecification 1128entryRuleObjective
1129: 1129:
1130{ before(grammarAccess.getScopeSpecificationRule()); } 1130{ before(grammarAccess.getObjectiveRule()); }
1131 ruleScopeSpecification 1131 ruleObjective
1132{ after(grammarAccess.getScopeSpecificationRule()); } 1132{ after(grammarAccess.getObjectiveRule()); }
1133 EOF 1133 EOF
1134; 1134;
1135 1135
1136// Rule ScopeSpecification 1136// Rule Objective
1137ruleScopeSpecification 1137ruleObjective
1138 @init { 1138 @init {
1139 int stackSize = keepStackSize(); 1139 int stackSize = keepStackSize();
1140 } 1140 }
1141 : 1141 :
1142 ( 1142 (
1143 { before(grammarAccess.getScopeSpecificationAccess().getGroup()); } 1143 { before(grammarAccess.getObjectiveAccess().getAlternatives()); }
1144 (rule__ScopeSpecification__Group__0) 1144 (rule__Objective__Alternatives)
1145 { after(grammarAccess.getScopeSpecificationAccess().getGroup()); } 1145 { after(grammarAccess.getObjectiveAccess().getAlternatives()); }
1146 ) 1146 )
1147; 1147;
1148finally { 1148finally {
1149 restoreStackSize(stackSize); 1149 restoreStackSize(stackSize);
1150} 1150}
1151 1151
1152// Entry rule entryRuleTypeScope 1152// Entry rule entryRuleConfigSpecification
1153entryRuleTypeScope 1153entryRuleConfigSpecification
1154: 1154:
1155{ before(grammarAccess.getTypeScopeRule()); } 1155{ before(grammarAccess.getConfigSpecificationRule()); }
1156 ruleTypeScope 1156 ruleConfigSpecification
1157{ after(grammarAccess.getTypeScopeRule()); } 1157{ after(grammarAccess.getConfigSpecificationRule()); }
1158 EOF 1158 EOF
1159; 1159;
1160 1160
1161// Rule TypeScope 1161// Rule ConfigSpecification
1162ruleTypeScope 1162ruleConfigSpecification
1163 @init { 1163 @init {
1164 int stackSize = keepStackSize(); 1164 int stackSize = keepStackSize();
1165 } 1165 }
1166 : 1166 :
1167 ( 1167 (
1168 { before(grammarAccess.getTypeScopeAccess().getAlternatives()); } 1168 { before(grammarAccess.getConfigSpecificationAccess().getGroup()); }
1169 (rule__TypeScope__Alternatives) 1169 (rule__ConfigSpecification__Group__0)
1170 { after(grammarAccess.getTypeScopeAccess().getAlternatives()); } 1170 { after(grammarAccess.getConfigSpecificationAccess().getGroup()); }
1171 ) 1171 )
1172; 1172;
1173finally { 1173finally {
1174 restoreStackSize(stackSize); 1174 restoreStackSize(stackSize);
1175} 1175}
1176 1176
1177// Entry rule entryRuleClassTypeScope 1177// Entry rule entryRuleConfigDeclaration
1178entryRuleClassTypeScope 1178entryRuleConfigDeclaration
1179: 1179:
1180{ before(grammarAccess.getClassTypeScopeRule()); } 1180{ before(grammarAccess.getConfigDeclarationRule()); }
1181 ruleClassTypeScope 1181 ruleConfigDeclaration
1182{ after(grammarAccess.getClassTypeScopeRule()); } 1182{ after(grammarAccess.getConfigDeclarationRule()); }
1183 EOF 1183 EOF
1184; 1184;
1185 1185
1186// Rule ClassTypeScope 1186// Rule ConfigDeclaration
1187ruleClassTypeScope 1187ruleConfigDeclaration
1188 @init { 1188 @init {
1189 int stackSize = keepStackSize(); 1189 int stackSize = keepStackSize();
1190 } 1190 }
1191 : 1191 :
1192 ( 1192 (
1193 { before(grammarAccess.getClassTypeScopeAccess().getGroup()); } 1193 { before(grammarAccess.getConfigDeclarationAccess().getGroup()); }
1194 (rule__ClassTypeScope__Group__0) 1194 (rule__ConfigDeclaration__Group__0)
1195 { after(grammarAccess.getClassTypeScopeAccess().getGroup()); } 1195 { after(grammarAccess.getConfigDeclarationAccess().getGroup()); }
1196 ) 1196 )
1197; 1197;
1198finally { 1198finally {
1199 restoreStackSize(stackSize); 1199 restoreStackSize(stackSize);
1200} 1200}
1201 1201
1202// Entry rule entryRuleObjectTypeScope 1202// Entry rule entryRuleConfigEntry
1203entryRuleObjectTypeScope 1203entryRuleConfigEntry
1204: 1204:
1205{ before(grammarAccess.getObjectTypeScopeRule()); } 1205{ before(grammarAccess.getConfigEntryRule()); }
1206 ruleObjectTypeScope 1206 ruleConfigEntry
1207{ after(grammarAccess.getObjectTypeScopeRule()); } 1207{ after(grammarAccess.getConfigEntryRule()); }
1208 EOF 1208 EOF
1209; 1209;
1210 1210
1211// Rule ObjectTypeScope 1211// Rule ConfigEntry
1212ruleObjectTypeScope 1212ruleConfigEntry
1213 @init { 1213 @init {
1214 int stackSize = keepStackSize(); 1214 int stackSize = keepStackSize();
1215 } 1215 }
1216 : 1216 :
1217 ( 1217 (
1218 { before(grammarAccess.getObjectTypeScopeAccess().getGroup()); } 1218 { before(grammarAccess.getConfigEntryAccess().getAlternatives()); }
1219 (rule__ObjectTypeScope__Group__0) 1219 (rule__ConfigEntry__Alternatives)
1220 { after(grammarAccess.getObjectTypeScopeAccess().getGroup()); } 1220 { after(grammarAccess.getConfigEntryAccess().getAlternatives()); }
1221 ) 1221 )
1222; 1222;
1223finally { 1223finally {
1224 restoreStackSize(stackSize); 1224 restoreStackSize(stackSize);
1225} 1225}
1226 1226
1227// Entry rule entryRuleIntegerTypeScope 1227// Entry rule entryRuleDocumentationEntry
1228entryRuleIntegerTypeScope 1228entryRuleDocumentationEntry
1229: 1229:
1230{ before(grammarAccess.getIntegerTypeScopeRule()); } 1230{ before(grammarAccess.getDocumentationEntryRule()); }
1231 ruleIntegerTypeScope 1231 ruleDocumentationEntry
1232{ after(grammarAccess.getIntegerTypeScopeRule()); } 1232{ after(grammarAccess.getDocumentationEntryRule()); }
1233 EOF 1233 EOF
1234; 1234;
1235 1235
1236// Rule IntegerTypeScope 1236// Rule DocumentationEntry
1237ruleIntegerTypeScope 1237ruleDocumentationEntry
1238 @init { 1238 @init {
1239 int stackSize = keepStackSize(); 1239 int stackSize = keepStackSize();
1240 } 1240 }
1241 : 1241 :
1242 ( 1242 (
1243 { before(grammarAccess.getIntegerTypeScopeAccess().getGroup()); } 1243 { before(grammarAccess.getDocumentationEntryAccess().getGroup()); }
1244 (rule__IntegerTypeScope__Group__0) 1244 (rule__DocumentationEntry__Group__0)
1245 { after(grammarAccess.getIntegerTypeScopeAccess().getGroup()); } 1245 { after(grammarAccess.getDocumentationEntryAccess().getGroup()); }
1246 ) 1246 )
1247; 1247;
1248finally { 1248finally {
1249 restoreStackSize(stackSize); 1249 restoreStackSize(stackSize);
1250} 1250}
1251 1251
1252// Entry rule entryRuleRealTypeScope 1252// Entry rule entryRuleRuntimeEntry
1253entryRuleRealTypeScope 1253entryRuleRuntimeEntry
1254: 1254:
1255{ before(grammarAccess.getRealTypeScopeRule()); } 1255{ before(grammarAccess.getRuntimeEntryRule()); }
1256 ruleRealTypeScope 1256 ruleRuntimeEntry
1257{ after(grammarAccess.getRealTypeScopeRule()); } 1257{ after(grammarAccess.getRuntimeEntryRule()); }
1258 EOF 1258 EOF
1259; 1259;
1260 1260
1261// Rule RealTypeScope 1261// Rule RuntimeEntry
1262ruleRealTypeScope 1262ruleRuntimeEntry
1263 @init { 1263 @init {
1264 int stackSize = keepStackSize(); 1264 int stackSize = keepStackSize();
1265 } 1265 }
1266 : 1266 :
1267 ( 1267 (
1268 { before(grammarAccess.getRealTypeScopeAccess().getGroup()); } 1268 { before(grammarAccess.getRuntimeEntryAccess().getGroup()); }
1269 (rule__RealTypeScope__Group__0) 1269 (rule__RuntimeEntry__Group__0)
1270 { after(grammarAccess.getRealTypeScopeAccess().getGroup()); } 1270 { after(grammarAccess.getRuntimeEntryAccess().getGroup()); }
1271 ) 1271 )
1272; 1272;
1273finally { 1273finally {
1274 restoreStackSize(stackSize); 1274 restoreStackSize(stackSize);
1275} 1275}
1276 1276
1277// Entry rule entryRuleStringTypeScope 1277// Entry rule entryRuleMemoryEntry
1278entryRuleStringTypeScope 1278entryRuleMemoryEntry
1279: 1279:
1280{ before(grammarAccess.getStringTypeScopeRule()); } 1280{ before(grammarAccess.getMemoryEntryRule()); }
1281 ruleStringTypeScope 1281 ruleMemoryEntry
1282{ after(grammarAccess.getStringTypeScopeRule()); } 1282{ after(grammarAccess.getMemoryEntryRule()); }
1283 EOF 1283 EOF
1284; 1284;
1285 1285
1286// Rule StringTypeScope 1286// Rule MemoryEntry
1287ruleStringTypeScope 1287ruleMemoryEntry
1288 @init { 1288 @init {
1289 int stackSize = keepStackSize(); 1289 int stackSize = keepStackSize();
1290 } 1290 }
1291 : 1291 :
1292 ( 1292 (
1293 { before(grammarAccess.getStringTypeScopeAccess().getGroup()); } 1293 { before(grammarAccess.getMemoryEntryAccess().getGroup()); }
1294 (rule__StringTypeScope__Group__0) 1294 (rule__MemoryEntry__Group__0)
1295 { after(grammarAccess.getStringTypeScopeAccess().getGroup()); } 1295 { after(grammarAccess.getMemoryEntryAccess().getGroup()); }
1296 ) 1296 )
1297; 1297;
1298finally { 1298finally {
1299 restoreStackSize(stackSize); 1299 restoreStackSize(stackSize);
1300} 1300}
1301 1301
1302// Entry rule entryRuleClassReference 1302// Entry rule entryRuleCustomEntry
1303entryRuleClassReference 1303entryRuleCustomEntry
1304: 1304:
1305{ before(grammarAccess.getClassReferenceRule()); } 1305{ before(grammarAccess.getCustomEntryRule()); }
1306 ruleClassReference 1306 ruleCustomEntry
1307{ after(grammarAccess.getClassReferenceRule()); } 1307{ after(grammarAccess.getCustomEntryRule()); }
1308 EOF 1308 EOF
1309; 1309;
1310 1310
1311// Rule ClassReference 1311// Rule CustomEntry
1312ruleClassReference 1312ruleCustomEntry
1313 @init { 1313 @init {
1314 int stackSize = keepStackSize(); 1314 int stackSize = keepStackSize();
1315 } 1315 }
1316 : 1316 :
1317 ( 1317 (
1318 { before(grammarAccess.getClassReferenceAccess().getGroup()); } 1318 { before(grammarAccess.getCustomEntryAccess().getGroup()); }
1319 (rule__ClassReference__Group__0) 1319 (rule__CustomEntry__Group__0)
1320 { after(grammarAccess.getClassReferenceAccess().getGroup()); } 1320 { after(grammarAccess.getCustomEntryAccess().getGroup()); }
1321 ) 1321 )
1322; 1322;
1323finally { 1323finally {
1324 restoreStackSize(stackSize); 1324 restoreStackSize(stackSize);
1325} 1325}
1326 1326
1327// Entry rule entryRuleObjectReference 1327// Entry rule entryRuleConfigReference
1328entryRuleObjectReference 1328entryRuleConfigReference
1329: 1329:
1330{ before(grammarAccess.getObjectReferenceRule()); } 1330{ before(grammarAccess.getConfigReferenceRule()); }
1331 ruleObjectReference 1331 ruleConfigReference
1332{ after(grammarAccess.getObjectReferenceRule()); } 1332{ after(grammarAccess.getConfigReferenceRule()); }
1333 EOF 1333 EOF
1334; 1334;
1335 1335
1336// Rule ObjectReference 1336// Rule ConfigReference
1337ruleObjectReference 1337ruleConfigReference
1338 @init { 1338 @init {
1339 int stackSize = keepStackSize(); 1339 int stackSize = keepStackSize();
1340 } 1340 }
1341 : 1341 :
1342 ( 1342 (
1343 { before(grammarAccess.getObjectReferenceAccess().getGroup()); } 1343 { before(grammarAccess.getConfigReferenceAccess().getConfigAssignment()); }
1344 (rule__ObjectReference__Group__0) 1344 (rule__ConfigReference__ConfigAssignment)
1345 { after(grammarAccess.getObjectReferenceAccess().getGroup()); } 1345 { after(grammarAccess.getConfigReferenceAccess().getConfigAssignment()); }
1346 ) 1346 )
1347; 1347;
1348finally { 1348finally {
1349 restoreStackSize(stackSize); 1349 restoreStackSize(stackSize);
1350} 1350}
1351 1351
1352// Entry rule entryRuleIntegerReference 1352// Entry rule entryRuleConfig
1353entryRuleIntegerReference 1353entryRuleConfig
1354: 1354:
1355{ before(grammarAccess.getIntegerReferenceRule()); } 1355{ before(grammarAccess.getConfigRule()); }
1356 ruleIntegerReference 1356 ruleConfig
1357{ after(grammarAccess.getIntegerReferenceRule()); } 1357{ after(grammarAccess.getConfigRule()); }
1358 EOF 1358 EOF
1359; 1359;
1360 1360
1361// Rule IntegerReference 1361// Rule Config
1362ruleIntegerReference 1362ruleConfig
1363 @init { 1363 @init {
1364 int stackSize = keepStackSize(); 1364 int stackSize = keepStackSize();
1365 } 1365 }
1366 : 1366 :
1367 ( 1367 (
1368 { before(grammarAccess.getIntegerReferenceAccess().getGroup()); } 1368 { before(grammarAccess.getConfigAccess().getAlternatives()); }
1369 (rule__IntegerReference__Group__0) 1369 (rule__Config__Alternatives)
1370 { after(grammarAccess.getIntegerReferenceAccess().getGroup()); } 1370 { after(grammarAccess.getConfigAccess().getAlternatives()); }
1371 ) 1371 )
1372; 1372;
1373finally { 1373finally {
1374 restoreStackSize(stackSize); 1374 restoreStackSize(stackSize);
1375} 1375}
1376 1376
1377// Entry rule entryRuleRealReference 1377// Entry rule entryRuleScopeSpecification
1378entryRuleRealReference 1378entryRuleScopeSpecification
1379: 1379:
1380{ before(grammarAccess.getRealReferenceRule()); } 1380{ before(grammarAccess.getScopeSpecificationRule()); }
1381 ruleRealReference 1381 ruleScopeSpecification
1382{ after(grammarAccess.getRealReferenceRule()); } 1382{ after(grammarAccess.getScopeSpecificationRule()); }
1383 EOF 1383 EOF
1384; 1384;
1385 1385
1386// Rule RealReference 1386// Rule ScopeSpecification
1387ruleRealReference 1387ruleScopeSpecification
1388 @init { 1388 @init {
1389 int stackSize = keepStackSize(); 1389 int stackSize = keepStackSize();
1390 } 1390 }
1391 : 1391 :
1392 ( 1392 (
1393 { before(grammarAccess.getRealReferenceAccess().getGroup()); } 1393 { before(grammarAccess.getScopeSpecificationAccess().getGroup()); }
1394 (rule__RealReference__Group__0) 1394 (rule__ScopeSpecification__Group__0)
1395 { after(grammarAccess.getRealReferenceAccess().getGroup()); } 1395 { after(grammarAccess.getScopeSpecificationAccess().getGroup()); }
1396 ) 1396 )
1397; 1397;
1398finally { 1398finally {
1399 restoreStackSize(stackSize); 1399 restoreStackSize(stackSize);
1400} 1400}
1401 1401
1402// Entry rule entryRuleStringReference 1402// Entry rule entryRuleTypeScope
1403entryRuleStringReference 1403entryRuleTypeScope
1404: 1404:
1405{ before(grammarAccess.getStringReferenceRule()); } 1405{ before(grammarAccess.getTypeScopeRule()); }
1406 ruleStringReference 1406 ruleTypeScope
1407{ after(grammarAccess.getStringReferenceRule()); } 1407{ after(grammarAccess.getTypeScopeRule()); }
1408 EOF 1408 EOF
1409; 1409;
1410 1410
1411// Rule StringReference 1411// Rule TypeScope
1412ruleStringReference 1412ruleTypeScope
1413 @init { 1413 @init {
1414 int stackSize = keepStackSize(); 1414 int stackSize = keepStackSize();
1415 } 1415 }
1416 : 1416 :
1417 ( 1417 (
1418 { before(grammarAccess.getStringReferenceAccess().getGroup()); } 1418 { before(grammarAccess.getTypeScopeAccess().getAlternatives()); }
1419 (rule__StringReference__Group__0) 1419 (rule__TypeScope__Alternatives)
1420 { after(grammarAccess.getStringReferenceAccess().getGroup()); } 1420 { after(grammarAccess.getTypeScopeAccess().getAlternatives()); }
1421 ) 1421 )
1422; 1422;
1423finally { 1423finally {
1424 restoreStackSize(stackSize); 1424 restoreStackSize(stackSize);
1425} 1425}
1426 1426
1427// Entry rule entryRuleExactNumber 1427// Entry rule entryRuleClassTypeScope
1428entryRuleExactNumber 1428entryRuleClassTypeScope
1429: 1429:
1430{ before(grammarAccess.getExactNumberRule()); } 1430{ before(grammarAccess.getClassTypeScopeRule()); }
1431 ruleExactNumber 1431 ruleClassTypeScope
1432{ after(grammarAccess.getExactNumberRule()); } 1432{ after(grammarAccess.getClassTypeScopeRule()); }
1433 EOF 1433 EOF
1434; 1434;
1435 1435
1436// Rule ExactNumber 1436// Rule ClassTypeScope
1437ruleExactNumber 1437ruleClassTypeScope
1438 @init { 1438 @init {
1439 int stackSize = keepStackSize(); 1439 int stackSize = keepStackSize();
1440 } 1440 }
1441 : 1441 :
1442 ( 1442 (
1443 { before(grammarAccess.getExactNumberAccess().getAlternatives()); } 1443 { before(grammarAccess.getClassTypeScopeAccess().getGroup()); }
1444 (rule__ExactNumber__Alternatives) 1444 (rule__ClassTypeScope__Group__0)
1445 { after(grammarAccess.getExactNumberAccess().getAlternatives()); } 1445 { after(grammarAccess.getClassTypeScopeAccess().getGroup()); }
1446 ) 1446 )
1447; 1447;
1448finally { 1448finally {
1449 restoreStackSize(stackSize); 1449 restoreStackSize(stackSize);
1450} 1450}
1451 1451
1452// Entry rule entryRuleIntervallNumber 1452// Entry rule entryRuleObjectTypeScope
1453entryRuleIntervallNumber 1453entryRuleObjectTypeScope
1454: 1454:
1455{ before(grammarAccess.getIntervallNumberRule()); } 1455{ before(grammarAccess.getObjectTypeScopeRule()); }
1456 ruleIntervallNumber 1456 ruleObjectTypeScope
1457{ after(grammarAccess.getIntervallNumberRule()); } 1457{ after(grammarAccess.getObjectTypeScopeRule()); }
1458 EOF 1458 EOF
1459; 1459;
1460 1460
1461// Rule IntervallNumber 1461// Rule ObjectTypeScope
1462ruleIntervallNumber 1462ruleObjectTypeScope
1463 @init { 1463 @init {
1464 int stackSize = keepStackSize(); 1464 int stackSize = keepStackSize();
1465 } 1465 }
1466 : 1466 :
1467 ( 1467 (
1468 { before(grammarAccess.getIntervallNumberAccess().getGroup()); } 1468 { before(grammarAccess.getObjectTypeScopeAccess().getGroup()); }
1469 (rule__IntervallNumber__Group__0) 1469 (rule__ObjectTypeScope__Group__0)
1470 { after(grammarAccess.getIntervallNumberAccess().getGroup()); } 1470 { after(grammarAccess.getObjectTypeScopeAccess().getGroup()); }
1471 ) 1471 )
1472; 1472;
1473finally { 1473finally {
1474 restoreStackSize(stackSize); 1474 restoreStackSize(stackSize);
1475} 1475}
1476 1476
1477// Entry rule entryRuleIntEnumberation 1477// Entry rule entryRuleIntegerTypeScope
1478entryRuleIntEnumberation 1478entryRuleIntegerTypeScope
1479: 1479:
1480{ before(grammarAccess.getIntEnumberationRule()); } 1480{ before(grammarAccess.getIntegerTypeScopeRule()); }
1481 ruleIntEnumberation 1481 ruleIntegerTypeScope
1482{ after(grammarAccess.getIntEnumberationRule()); } 1482{ after(grammarAccess.getIntegerTypeScopeRule()); }
1483 EOF 1483 EOF
1484; 1484;
1485 1485
1486// Rule IntEnumberation 1486// Rule IntegerTypeScope
1487ruleIntEnumberation 1487ruleIntegerTypeScope
1488 @init { 1488 @init {
1489 int stackSize = keepStackSize(); 1489 int stackSize = keepStackSize();
1490 } 1490 }
1491 : 1491 :
1492 ( 1492 (
1493 { before(grammarAccess.getIntEnumberationAccess().getGroup()); } 1493 { before(grammarAccess.getIntegerTypeScopeAccess().getGroup()); }
1494 (rule__IntEnumberation__Group__0) 1494 (rule__IntegerTypeScope__Group__0)
1495 { after(grammarAccess.getIntEnumberationAccess().getGroup()); } 1495 { after(grammarAccess.getIntegerTypeScopeAccess().getGroup()); }
1496 ) 1496 )
1497; 1497;
1498finally { 1498finally {
1499 restoreStackSize(stackSize); 1499 restoreStackSize(stackSize);
1500} 1500}
1501 1501
1502// Entry rule entryRuleRealEnumeration 1502// Entry rule entryRuleRealTypeScope
1503entryRuleRealEnumeration 1503entryRuleRealTypeScope
1504: 1504:
1505{ before(grammarAccess.getRealEnumerationRule()); } 1505{ before(grammarAccess.getRealTypeScopeRule()); }
1506 ruleRealEnumeration 1506 ruleRealTypeScope
1507{ after(grammarAccess.getRealEnumerationRule()); } 1507{ after(grammarAccess.getRealTypeScopeRule()); }
1508 EOF 1508 EOF
1509; 1509;
1510 1510
1511// Rule RealEnumeration 1511// Rule RealTypeScope
1512ruleRealEnumeration 1512ruleRealTypeScope
1513 @init { 1513 @init {
1514 int stackSize = keepStackSize(); 1514 int stackSize = keepStackSize();
1515 } 1515 }
1516 : 1516 :
1517 ( 1517 (
1518 { before(grammarAccess.getRealEnumerationAccess().getGroup()); } 1518 { before(grammarAccess.getRealTypeScopeAccess().getGroup()); }
1519 (rule__RealEnumeration__Group__0) 1519 (rule__RealTypeScope__Group__0)
1520 { after(grammarAccess.getRealEnumerationAccess().getGroup()); } 1520 { after(grammarAccess.getRealTypeScopeAccess().getGroup()); }
1521 ) 1521 )
1522; 1522;
1523finally { 1523finally {
1524 restoreStackSize(stackSize); 1524 restoreStackSize(stackSize);
1525} 1525}
1526 1526
1527// Entry rule entryRuleStringEnumeration 1527// Entry rule entryRuleStringTypeScope
1528entryRuleStringEnumeration 1528entryRuleStringTypeScope
1529: 1529:
1530{ before(grammarAccess.getStringEnumerationRule()); } 1530{ before(grammarAccess.getStringTypeScopeRule()); }
1531 ruleStringEnumeration 1531 ruleStringTypeScope
1532{ after(grammarAccess.getStringEnumerationRule()); } 1532{ after(grammarAccess.getStringTypeScopeRule()); }
1533 EOF 1533 EOF
1534; 1534;
1535 1535
1536// Rule StringEnumeration 1536// Rule StringTypeScope
1537ruleStringEnumeration 1537ruleStringTypeScope
1538 @init { 1538 @init {
1539 int stackSize = keepStackSize(); 1539 int stackSize = keepStackSize();
1540 } 1540 }
1541 : 1541 :
1542 ( 1542 (
1543 { before(grammarAccess.getStringEnumerationAccess().getGroup()); } 1543 { before(grammarAccess.getStringTypeScopeAccess().getGroup()); }
1544 (rule__StringEnumeration__Group__0) 1544 (rule__StringTypeScope__Group__0)
1545 { after(grammarAccess.getStringEnumerationAccess().getGroup()); } 1545 { after(grammarAccess.getStringTypeScopeAccess().getGroup()); }
1546 ) 1546 )
1547; 1547;
1548finally { 1548finally {
1549 restoreStackSize(stackSize); 1549 restoreStackSize(stackSize);
1550} 1550}
1551 1551
1552// Entry rule entryRuleScopeDeclaration 1552// Entry rule entryRuleClassReference
1553entryRuleScopeDeclaration 1553entryRuleClassReference
1554: 1554:
1555{ before(grammarAccess.getScopeDeclarationRule()); } 1555{ before(grammarAccess.getClassReferenceRule()); }
1556 ruleScopeDeclaration 1556 ruleClassReference
1557{ after(grammarAccess.getScopeDeclarationRule()); } 1557{ after(grammarAccess.getClassReferenceRule()); }
1558 EOF 1558 EOF
1559; 1559;
1560 1560
1561// Rule ScopeDeclaration 1561// Rule ClassReference
1562ruleScopeDeclaration 1562ruleClassReference
1563 @init { 1563 @init {
1564 int stackSize = keepStackSize(); 1564 int stackSize = keepStackSize();
1565 } 1565 }
1566 : 1566 :
1567 ( 1567 (
1568 { before(grammarAccess.getScopeDeclarationAccess().getGroup()); } 1568 { before(grammarAccess.getClassReferenceAccess().getGroup()); }
1569 (rule__ScopeDeclaration__Group__0) 1569 (rule__ClassReference__Group__0)
1570 { after(grammarAccess.getScopeDeclarationAccess().getGroup()); } 1570 { after(grammarAccess.getClassReferenceAccess().getGroup()); }
1571 ) 1571 )
1572; 1572;
1573finally { 1573finally {
1574 restoreStackSize(stackSize); 1574 restoreStackSize(stackSize);
1575} 1575}
1576 1576
1577// Entry rule entryRuleScopeReference 1577// Entry rule entryRuleObjectReference
1578entryRuleScopeReference 1578entryRuleObjectReference
1579: 1579:
1580{ before(grammarAccess.getScopeReferenceRule()); } 1580{ before(grammarAccess.getObjectReferenceRule()); }
1581 ruleScopeReference 1581 ruleObjectReference
1582{ after(grammarAccess.getScopeReferenceRule()); } 1582{ after(grammarAccess.getObjectReferenceRule()); }
1583 EOF 1583 EOF
1584; 1584;
1585 1585
1586// Rule ScopeReference 1586// Rule ObjectReference
1587ruleScopeReference 1587ruleObjectReference
1588 @init { 1588 @init {
1589 int stackSize = keepStackSize(); 1589 int stackSize = keepStackSize();
1590 } 1590 }
1591 : 1591 :
1592 ( 1592 (
1593 { before(grammarAccess.getScopeReferenceAccess().getReferredAssignment()); } 1593 { before(grammarAccess.getObjectReferenceAccess().getGroup()); }
1594 (rule__ScopeReference__ReferredAssignment) 1594 (rule__ObjectReference__Group__0)
1595 { after(grammarAccess.getScopeReferenceAccess().getReferredAssignment()); } 1595 { after(grammarAccess.getObjectReferenceAccess().getGroup()); }
1596 ) 1596 )
1597; 1597;
1598finally { 1598finally {
1599 restoreStackSize(stackSize); 1599 restoreStackSize(stackSize);
1600} 1600}
1601 1601
1602// Entry rule entryRuleScope 1602// Entry rule entryRuleIntegerReference
1603entryRuleScope 1603entryRuleIntegerReference
1604: 1604:
1605{ before(grammarAccess.getScopeRule()); } 1605{ before(grammarAccess.getIntegerReferenceRule()); }
1606 ruleScope 1606 ruleIntegerReference
1607{ after(grammarAccess.getScopeRule()); } 1607{ after(grammarAccess.getIntegerReferenceRule()); }
1608 EOF 1608 EOF
1609; 1609;
1610 1610
1611// Rule Scope 1611// Rule IntegerReference
1612ruleScope 1612ruleIntegerReference
1613 @init { 1613 @init {
1614 int stackSize = keepStackSize(); 1614 int stackSize = keepStackSize();
1615 } 1615 }
1616 : 1616 :
1617 ( 1617 (
1618 { before(grammarAccess.getScopeAccess().getAlternatives()); } 1618 { before(grammarAccess.getIntegerReferenceAccess().getGroup()); }
1619 (rule__Scope__Alternatives) 1619 (rule__IntegerReference__Group__0)
1620 { after(grammarAccess.getScopeAccess().getAlternatives()); } 1620 { after(grammarAccess.getIntegerReferenceAccess().getGroup()); }
1621 ) 1621 )
1622; 1622;
1623finally { 1623finally {
1624 restoreStackSize(stackSize); 1624 restoreStackSize(stackSize);
1625} 1625}
1626 1626
1627// Entry rule entryRuleTask 1627// Entry rule entryRuleRealReference
1628entryRuleTask 1628entryRuleRealReference
1629: 1629:
1630{ before(grammarAccess.getTaskRule()); } 1630{ before(grammarAccess.getRealReferenceRule()); }
1631 ruleTask 1631 ruleRealReference
1632{ after(grammarAccess.getTaskRule()); } 1632{ after(grammarAccess.getRealReferenceRule()); }
1633 EOF 1633 EOF
1634; 1634;
1635 1635
1636// Rule Task 1636// Rule RealReference
1637ruleTask 1637ruleRealReference
1638 @init { 1638 @init {
1639 int stackSize = keepStackSize(); 1639 int stackSize = keepStackSize();
1640 } 1640 }
1641 : 1641 :
1642 ( 1642 (
1643 { before(grammarAccess.getTaskAccess().getGenerationTaskParserRuleCall()); } 1643 { before(grammarAccess.getRealReferenceAccess().getGroup()); }
1644 ruleGenerationTask 1644 (rule__RealReference__Group__0)
1645 { after(grammarAccess.getTaskAccess().getGenerationTaskParserRuleCall()); } 1645 { after(grammarAccess.getRealReferenceAccess().getGroup()); }
1646 ) 1646 )
1647; 1647;
1648finally { 1648finally {
1649 restoreStackSize(stackSize); 1649 restoreStackSize(stackSize);
1650} 1650}
1651 1651
1652// Entry rule entryRuleGenerationTask 1652// Entry rule entryRuleStringReference
1653entryRuleGenerationTask 1653entryRuleStringReference
1654: 1654:
1655{ before(grammarAccess.getGenerationTaskRule()); } 1655{ before(grammarAccess.getStringReferenceRule()); }
1656 ruleGenerationTask 1656 ruleStringReference
1657{ after(grammarAccess.getGenerationTaskRule()); } 1657{ after(grammarAccess.getStringReferenceRule()); }
1658 EOF 1658 EOF
1659; 1659;
1660 1660
1661// Rule GenerationTask 1661// Rule StringReference
1662ruleGenerationTask 1662ruleStringReference
1663 @init { 1663 @init {
1664 int stackSize = keepStackSize(); 1664 int stackSize = keepStackSize();
1665 } 1665 }
1666 : 1666 :
1667 ( 1667 (
1668 { before(grammarAccess.getGenerationTaskAccess().getGroup()); } 1668 { before(grammarAccess.getStringReferenceAccess().getGroup()); }
1669 (rule__GenerationTask__Group__0) 1669 (rule__StringReference__Group__0)
1670 { after(grammarAccess.getGenerationTaskAccess().getGroup()); } 1670 { after(grammarAccess.getStringReferenceAccess().getGroup()); }
1671 ) 1671 )
1672; 1672;
1673finally { 1673finally {
1674 restoreStackSize(stackSize); 1674 restoreStackSize(stackSize);
1675} 1675}
1676 1676
1677// Rule DocumentLevelSpecification 1677// Entry rule entryRuleExactNumber
1678ruleDocumentLevelSpecification 1678entryRuleExactNumber
1679 @init { 1679:
1680 int stackSize = keepStackSize(); 1680{ before(grammarAccess.getExactNumberRule()); }
1681 } 1681 ruleExactNumber
1682: 1682{ after(grammarAccess.getExactNumberRule()); }
1683 ( 1683 EOF
1684 { before(grammarAccess.getDocumentLevelSpecificationAccess().getAlternatives()); } 1684;
1685 (rule__DocumentLevelSpecification__Alternatives) 1685
1686 { after(grammarAccess.getDocumentLevelSpecificationAccess().getAlternatives()); } 1686// Rule ExactNumber
1687 ) 1687ruleExactNumber
1688; 1688 @init {
1689finally { 1689 int stackSize = keepStackSize();
1690 restoreStackSize(stackSize); 1690 }
1691} 1691 :
1692 1692 (
1693// Rule Solver 1693 { before(grammarAccess.getExactNumberAccess().getAlternatives()); }
1694ruleSolver 1694 (rule__ExactNumber__Alternatives)
1695 @init { 1695 { after(grammarAccess.getExactNumberAccess().getAlternatives()); }
1696 int stackSize = keepStackSize(); 1696 )
1697 } 1697;
1698: 1698finally {
1699 ( 1699 restoreStackSize(stackSize);
1700 { before(grammarAccess.getSolverAccess().getAlternatives()); } 1700}
1701 (rule__Solver__Alternatives) 1701
1702 { after(grammarAccess.getSolverAccess().getAlternatives()); } 1702// Entry rule entryRuleIntervallNumber
1703 ) 1703entryRuleIntervallNumber
1704; 1704:
1705finally { 1705{ before(grammarAccess.getIntervallNumberRule()); }
1706 restoreStackSize(stackSize); 1706 ruleIntervallNumber
1707} 1707{ after(grammarAccess.getIntervallNumberRule()); }
1708 1708 EOF
1709rule__Command__Alternatives 1709;
1710 @init { 1710
1711 int stackSize = keepStackSize(); 1711// Rule IntervallNumber
1712 } 1712ruleIntervallNumber
1713: 1713 @init {
1714 ( 1714 int stackSize = keepStackSize();
1715 { before(grammarAccess.getCommandAccess().getDeclarationParserRuleCall_0()); } 1715 }
1716 ruleDeclaration 1716 :
1717 { after(grammarAccess.getCommandAccess().getDeclarationParserRuleCall_0()); } 1717 (
1718 ) 1718 { before(grammarAccess.getIntervallNumberAccess().getGroup()); }
1719 | 1719 (rule__IntervallNumber__Group__0)
1720 ( 1720 { after(grammarAccess.getIntervallNumberAccess().getGroup()); }
1721 { before(grammarAccess.getCommandAccess().getTaskParserRuleCall_1()); } 1721 )
1722 ruleTask 1722;
1723 { after(grammarAccess.getCommandAccess().getTaskParserRuleCall_1()); } 1723finally {
1724 ) 1724 restoreStackSize(stackSize);
1725; 1725}
1726finally { 1726
1727 restoreStackSize(stackSize); 1727// Entry rule entryRuleIntEnumberation
1728} 1728entryRuleIntEnumberation
1729 1729:
1730rule__Import__Alternatives 1730{ before(grammarAccess.getIntEnumberationRule()); }
1731 @init { 1731 ruleIntEnumberation
1732 int stackSize = keepStackSize(); 1732{ after(grammarAccess.getIntEnumberationRule()); }
1733 } 1733 EOF
1734: 1734;
1735 ( 1735
1736 { before(grammarAccess.getImportAccess().getEPackageImportParserRuleCall_0()); } 1736// Rule IntEnumberation
1737 ruleEPackageImport 1737ruleIntEnumberation
1738 { after(grammarAccess.getImportAccess().getEPackageImportParserRuleCall_0()); } 1738 @init {
1739 ) 1739 int stackSize = keepStackSize();
1740 | 1740 }
1741 ( 1741 :
1742 { before(grammarAccess.getImportAccess().getViatraImportParserRuleCall_1()); } 1742 (
1743 ruleViatraImport 1743 { before(grammarAccess.getIntEnumberationAccess().getGroup()); }
1744 { after(grammarAccess.getImportAccess().getViatraImportParserRuleCall_1()); } 1744 (rule__IntEnumberation__Group__0)
1745 ) 1745 { after(grammarAccess.getIntEnumberationAccess().getGroup()); }
1746; 1746 )
1747finally { 1747;
1748 restoreStackSize(stackSize); 1748finally {
1749} 1749 restoreStackSize(stackSize);
1750 1750}
1751rule__Declaration__Alternatives 1751
1752 @init { 1752// Entry rule entryRuleRealEnumeration
1753 int stackSize = keepStackSize(); 1753entryRuleRealEnumeration
1754 } 1754:
1755: 1755{ before(grammarAccess.getRealEnumerationRule()); }
1756 ( 1756 ruleRealEnumeration
1757 { before(grammarAccess.getDeclarationAccess().getFileDeclarationParserRuleCall_0()); } 1757{ after(grammarAccess.getRealEnumerationRule()); }
1758 ruleFileDeclaration 1758 EOF
1759 { after(grammarAccess.getDeclarationAccess().getFileDeclarationParserRuleCall_0()); } 1759;
1760 ) 1760
1761 | 1761// Rule RealEnumeration
1762 ( 1762ruleRealEnumeration
1763 { before(grammarAccess.getDeclarationAccess().getMetamodelDeclarationParserRuleCall_1()); } 1763 @init {
1764 ruleMetamodelDeclaration 1764 int stackSize = keepStackSize();
1765 { after(grammarAccess.getDeclarationAccess().getMetamodelDeclarationParserRuleCall_1()); } 1765 }
1766 ) 1766 :
1767 | 1767 (
1768 ( 1768 { before(grammarAccess.getRealEnumerationAccess().getGroup()); }
1769 { before(grammarAccess.getDeclarationAccess().getPartialModelDeclarationParserRuleCall_2()); } 1769 (rule__RealEnumeration__Group__0)
1770 rulePartialModelDeclaration 1770 { after(grammarAccess.getRealEnumerationAccess().getGroup()); }
1771 { after(grammarAccess.getDeclarationAccess().getPartialModelDeclarationParserRuleCall_2()); } 1771 )
1772 ) 1772;
1773 | 1773finally {
1774 ( 1774 restoreStackSize(stackSize);
1775 { before(grammarAccess.getDeclarationAccess().getGraphPatternDeclarationParserRuleCall_3()); } 1775}
1776 ruleGraphPatternDeclaration 1776
1777 { after(grammarAccess.getDeclarationAccess().getGraphPatternDeclarationParserRuleCall_3()); } 1777// Entry rule entryRuleStringEnumeration
1778 ) 1778entryRuleStringEnumeration
1779 | 1779:
1780 ( 1780{ before(grammarAccess.getStringEnumerationRule()); }
1781 { before(grammarAccess.getDeclarationAccess().getConfigDeclarationParserRuleCall_4()); } 1781 ruleStringEnumeration
1782 ruleConfigDeclaration 1782{ after(grammarAccess.getStringEnumerationRule()); }
1783 { after(grammarAccess.getDeclarationAccess().getConfigDeclarationParserRuleCall_4()); } 1783 EOF
1784 ) 1784;
1785 | 1785
1786 ( 1786// Rule StringEnumeration
1787 { before(grammarAccess.getDeclarationAccess().getScopeDeclarationParserRuleCall_5()); } 1787ruleStringEnumeration
1788 ruleScopeDeclaration 1788 @init {
1789 { after(grammarAccess.getDeclarationAccess().getScopeDeclarationParserRuleCall_5()); } 1789 int stackSize = keepStackSize();
1790 ) 1790 }
1791; 1791 :
1792finally { 1792 (
1793 restoreStackSize(stackSize); 1793 { before(grammarAccess.getStringEnumerationAccess().getGroup()); }
1794} 1794 (rule__StringEnumeration__Group__0)
1795 1795 { after(grammarAccess.getStringEnumerationAccess().getGroup()); }
1796rule__File__Alternatives 1796 )
1797 @init { 1797;
1798 int stackSize = keepStackSize(); 1798finally {
1799 } 1799 restoreStackSize(stackSize);
1800: 1800}
1801 ( 1801
1802 { before(grammarAccess.getFileAccess().getFileSpecificationParserRuleCall_0()); } 1802// Entry rule entryRuleScopeDeclaration
1803 ruleFileSpecification 1803entryRuleScopeDeclaration
1804 { after(grammarAccess.getFileAccess().getFileSpecificationParserRuleCall_0()); } 1804:
1805 ) 1805{ before(grammarAccess.getScopeDeclarationRule()); }
1806 | 1806 ruleScopeDeclaration
1807 ( 1807{ after(grammarAccess.getScopeDeclarationRule()); }
1808 { before(grammarAccess.getFileAccess().getFileReferenceParserRuleCall_1()); } 1808 EOF
1809 ruleFileReference 1809;
1810 { after(grammarAccess.getFileAccess().getFileReferenceParserRuleCall_1()); } 1810
1811 ) 1811// Rule ScopeDeclaration
1812; 1812ruleScopeDeclaration
1813finally { 1813 @init {
1814 restoreStackSize(stackSize); 1814 int stackSize = keepStackSize();
1815} 1815 }
1816 1816 :
1817rule__MetamodelEntry__Alternatives 1817 (
1818 @init { 1818 { before(grammarAccess.getScopeDeclarationAccess().getGroup()); }
1819 int stackSize = keepStackSize(); 1819 (rule__ScopeDeclaration__Group__0)
1820 } 1820 { after(grammarAccess.getScopeDeclarationAccess().getGroup()); }
1821: 1821 )
1822 ( 1822;
1823 { before(grammarAccess.getMetamodelEntryAccess().getMetamodelElementParserRuleCall_0()); } 1823finally {
1824 ruleMetamodelElement 1824 restoreStackSize(stackSize);
1825 { after(grammarAccess.getMetamodelEntryAccess().getMetamodelElementParserRuleCall_0()); } 1825}
1826 ) 1826
1827 | 1827// Entry rule entryRuleScopeReference
1828 ( 1828entryRuleScopeReference
1829 { before(grammarAccess.getMetamodelEntryAccess().getAllPackageEntryParserRuleCall_1()); } 1829:
1830 ruleAllPackageEntry 1830{ before(grammarAccess.getScopeReferenceRule()); }
1831 { after(grammarAccess.getMetamodelEntryAccess().getAllPackageEntryParserRuleCall_1()); } 1831 ruleScopeReference
1832 ) 1832{ after(grammarAccess.getScopeReferenceRule()); }
1833; 1833 EOF
1834finally { 1834;
1835 restoreStackSize(stackSize); 1835
1836} 1836// Rule ScopeReference
1837 1837ruleScopeReference
1838rule__Metamodel__Alternatives 1838 @init {
1839 @init { 1839 int stackSize = keepStackSize();
1840 int stackSize = keepStackSize(); 1840 }
1841 } 1841 :
1842: 1842 (
1843 ( 1843 { before(grammarAccess.getScopeReferenceAccess().getReferredAssignment()); }
1844 { before(grammarAccess.getMetamodelAccess().getMetamodelReferenceParserRuleCall_0()); } 1844 (rule__ScopeReference__ReferredAssignment)
1845 ruleMetamodelReference 1845 { after(grammarAccess.getScopeReferenceAccess().getReferredAssignment()); }
1846 { after(grammarAccess.getMetamodelAccess().getMetamodelReferenceParserRuleCall_0()); } 1846 )
1847 ) 1847;
1848 | 1848finally {
1849 ( 1849 restoreStackSize(stackSize);
1850 { before(grammarAccess.getMetamodelAccess().getMetamodelSpecificationParserRuleCall_1()); } 1850}
1851 ruleMetamodelSpecification 1851
1852 { after(grammarAccess.getMetamodelAccess().getMetamodelSpecificationParserRuleCall_1()); } 1852// Entry rule entryRuleScope
1853 ) 1853entryRuleScope
1854; 1854:
1855finally { 1855{ before(grammarAccess.getScopeRule()); }
1856 restoreStackSize(stackSize); 1856 ruleScope
1857} 1857{ after(grammarAccess.getScopeRule()); }
1858 1858 EOF
1859rule__PartialModelEntry__Alternatives 1859;
1860 @init { 1860
1861 int stackSize = keepStackSize(); 1861// Rule Scope
1862 } 1862ruleScope
1863: 1863 @init {
1864 ( 1864 int stackSize = keepStackSize();
1865 { before(grammarAccess.getPartialModelEntryAccess().getModelEntryParserRuleCall_0()); } 1865 }
1866 ruleModelEntry 1866 :
1867 { after(grammarAccess.getPartialModelEntryAccess().getModelEntryParserRuleCall_0()); } 1867 (
1868 ) 1868 { before(grammarAccess.getScopeAccess().getAlternatives()); }
1869 | 1869 (rule__Scope__Alternatives)
1870 ( 1870 { after(grammarAccess.getScopeAccess().getAlternatives()); }
1871 { before(grammarAccess.getPartialModelEntryAccess().getFolderEntryParserRuleCall_1()); } 1871 )
1872 ruleFolderEntry 1872;
1873 { after(grammarAccess.getPartialModelEntryAccess().getFolderEntryParserRuleCall_1()); } 1873finally {
1874 ) 1874 restoreStackSize(stackSize);
1875; 1875}
1876finally { 1876
1877 restoreStackSize(stackSize); 1877// Entry rule entryRuleTask
1878} 1878entryRuleTask
1879 1879:
1880rule__PartialModel__Alternatives 1880{ before(grammarAccess.getTaskRule()); }
1881 @init { 1881 ruleTask
1882 int stackSize = keepStackSize(); 1882{ after(grammarAccess.getTaskRule()); }
1883 } 1883 EOF
1884: 1884;
1885 ( 1885
1886 { before(grammarAccess.getPartialModelAccess().getPartialModelSpecificationParserRuleCall_0()); } 1886// Rule Task
1887 rulePartialModelSpecification 1887ruleTask
1888 { after(grammarAccess.getPartialModelAccess().getPartialModelSpecificationParserRuleCall_0()); } 1888 @init {
1889 ) 1889 int stackSize = keepStackSize();
1890 | 1890 }
1891 ( 1891 :
1892 { before(grammarAccess.getPartialModelAccess().getPartialModelReferenceParserRuleCall_1()); } 1892 (
1893 rulePartialModelReference 1893 { before(grammarAccess.getTaskAccess().getGenerationTaskParserRuleCall()); }
1894 { after(grammarAccess.getPartialModelAccess().getPartialModelReferenceParserRuleCall_1()); } 1894 ruleGenerationTask
1895 ) 1895 { after(grammarAccess.getTaskAccess().getGenerationTaskParserRuleCall()); }
1896; 1896 )
1897finally { 1897;
1898 restoreStackSize(stackSize); 1898finally {
1899} 1899 restoreStackSize(stackSize);
1900 1900}
1901rule__PatternEntry__Alternatives 1901
1902 @init { 1902// Entry rule entryRuleGenerationTask
1903 int stackSize = keepStackSize(); 1903entryRuleGenerationTask
1904 } 1904:
1905: 1905{ before(grammarAccess.getGenerationTaskRule()); }
1906 ( 1906 ruleGenerationTask
1907 { before(grammarAccess.getPatternEntryAccess().getPatternElementParserRuleCall_0()); } 1907{ after(grammarAccess.getGenerationTaskRule()); }
1908 rulePatternElement 1908 EOF
1909 { after(grammarAccess.getPatternEntryAccess().getPatternElementParserRuleCall_0()); } 1909;
1910 ) 1910
1911 | 1911// Rule GenerationTask
1912 ( 1912ruleGenerationTask
1913 { before(grammarAccess.getPatternEntryAccess().getAllPatternEntryParserRuleCall_1()); } 1913 @init {
1914 ruleAllPatternEntry 1914 int stackSize = keepStackSize();
1915 { after(grammarAccess.getPatternEntryAccess().getAllPatternEntryParserRuleCall_1()); } 1915 }
1916 ) 1916 :
1917; 1917 (
1918finally { 1918 { before(grammarAccess.getGenerationTaskAccess().getGroup()); }
1919 restoreStackSize(stackSize); 1919 (rule__GenerationTask__Group__0)
1920} 1920 { after(grammarAccess.getGenerationTaskAccess().getGroup()); }
1921 1921 )
1922rule__GraphPattern__Alternatives 1922;
1923 @init { 1923finally {
1924 int stackSize = keepStackSize(); 1924 restoreStackSize(stackSize);
1925 } 1925}
1926: 1926
1927 ( 1927// Rule OptimizationDirection
1928 { before(grammarAccess.getGraphPatternAccess().getGraphPatternReferenceParserRuleCall_0()); } 1928ruleOptimizationDirection
1929 ruleGraphPatternReference 1929 @init {
1930 { after(grammarAccess.getGraphPatternAccess().getGraphPatternReferenceParserRuleCall_0()); } 1930 int stackSize = keepStackSize();
1931 ) 1931 }
1932 | 1932:
1933 ( 1933 (
1934 { before(grammarAccess.getGraphPatternAccess().getPatternSpecificationParserRuleCall_1()); } 1934 { before(grammarAccess.getOptimizationDirectionAccess().getAlternatives()); }
1935 rulePatternSpecification 1935 (rule__OptimizationDirection__Alternatives)
1936 { after(grammarAccess.getGraphPatternAccess().getPatternSpecificationParserRuleCall_1()); } 1936 { after(grammarAccess.getOptimizationDirectionAccess().getAlternatives()); }
1937 ) 1937 )
1938; 1938;
1939finally { 1939finally {
1940 restoreStackSize(stackSize); 1940 restoreStackSize(stackSize);
1941} 1941}
1942 1942
1943rule__ConfigEntry__Alternatives 1943// Rule ComparisonOperator
1944 @init { 1944ruleComparisonOperator
1945 int stackSize = keepStackSize(); 1945 @init {
1946 } 1946 int stackSize = keepStackSize();
1947: 1947 }
1948 ( 1948:
1949 { before(grammarAccess.getConfigEntryAccess().getDocumentationEntryParserRuleCall_0()); } 1949 (
1950 ruleDocumentationEntry 1950 { before(grammarAccess.getComparisonOperatorAccess().getAlternatives()); }
1951 { after(grammarAccess.getConfigEntryAccess().getDocumentationEntryParserRuleCall_0()); } 1951 (rule__ComparisonOperator__Alternatives)
1952 ) 1952 { after(grammarAccess.getComparisonOperatorAccess().getAlternatives()); }
1953 | 1953 )
1954 ( 1954;
1955 { before(grammarAccess.getConfigEntryAccess().getRuntimeEntryParserRuleCall_1()); } 1955finally {
1956 ruleRuntimeEntry 1956 restoreStackSize(stackSize);
1957 { after(grammarAccess.getConfigEntryAccess().getRuntimeEntryParserRuleCall_1()); } 1957}
1958 ) 1958
1959 | 1959// Rule DocumentLevelSpecification
1960 ( 1960ruleDocumentLevelSpecification
1961 { before(grammarAccess.getConfigEntryAccess().getMemoryEntryParserRuleCall_2()); } 1961 @init {
1962 ruleMemoryEntry 1962 int stackSize = keepStackSize();
1963 { after(grammarAccess.getConfigEntryAccess().getMemoryEntryParserRuleCall_2()); } 1963 }
1964 ) 1964:
1965 | 1965 (
1966 ( 1966 { before(grammarAccess.getDocumentLevelSpecificationAccess().getAlternatives()); }
1967 { before(grammarAccess.getConfigEntryAccess().getCustomEntryParserRuleCall_3()); } 1967 (rule__DocumentLevelSpecification__Alternatives)
1968 ruleCustomEntry 1968 { after(grammarAccess.getDocumentLevelSpecificationAccess().getAlternatives()); }
1969 { after(grammarAccess.getConfigEntryAccess().getCustomEntryParserRuleCall_3()); } 1969 )
1970 ) 1970;
1971; 1971finally {
1972finally { 1972 restoreStackSize(stackSize);
1973 restoreStackSize(stackSize); 1973}
1974} 1974
1975 1975// Rule Solver
1976rule__Config__Alternatives 1976ruleSolver
1977 @init { 1977 @init {
1978 int stackSize = keepStackSize(); 1978 int stackSize = keepStackSize();
1979 } 1979 }
1980: 1980:
1981 ( 1981 (
1982 { before(grammarAccess.getConfigAccess().getConfigSpecificationParserRuleCall_0()); } 1982 { before(grammarAccess.getSolverAccess().getAlternatives()); }
1983 ruleConfigSpecification 1983 (rule__Solver__Alternatives)
1984 { after(grammarAccess.getConfigAccess().getConfigSpecificationParserRuleCall_0()); } 1984 { after(grammarAccess.getSolverAccess().getAlternatives()); }
1985 ) 1985 )
1986 | 1986;
1987 ( 1987finally {
1988 { before(grammarAccess.getConfigAccess().getConfigReferenceParserRuleCall_1()); } 1988 restoreStackSize(stackSize);
1989 ruleConfigReference 1989}
1990 { after(grammarAccess.getConfigAccess().getConfigReferenceParserRuleCall_1()); } 1990
1991 ) 1991rule__Command__Alternatives
1992; 1992 @init {
1993finally { 1993 int stackSize = keepStackSize();
1994 restoreStackSize(stackSize); 1994 }
1995} 1995:
1996 1996 (
1997rule__TypeScope__Alternatives 1997 { before(grammarAccess.getCommandAccess().getDeclarationParserRuleCall_0()); }
1998 @init { 1998 ruleDeclaration
1999 int stackSize = keepStackSize(); 1999 { after(grammarAccess.getCommandAccess().getDeclarationParserRuleCall_0()); }
2000 } 2000 )
2001: 2001 |
2002 ( 2002 (
2003 { before(grammarAccess.getTypeScopeAccess().getClassTypeScopeParserRuleCall_0()); } 2003 { before(grammarAccess.getCommandAccess().getTaskParserRuleCall_1()); }
2004 ruleClassTypeScope 2004 ruleTask
2005 { after(grammarAccess.getTypeScopeAccess().getClassTypeScopeParserRuleCall_0()); } 2005 { after(grammarAccess.getCommandAccess().getTaskParserRuleCall_1()); }
2006 ) 2006 )
2007 | 2007;
2008 ( 2008finally {
2009 { before(grammarAccess.getTypeScopeAccess().getObjectTypeScopeParserRuleCall_1()); } 2009 restoreStackSize(stackSize);
2010 ruleObjectTypeScope 2010}
2011 { after(grammarAccess.getTypeScopeAccess().getObjectTypeScopeParserRuleCall_1()); } 2011
2012 ) 2012rule__Import__Alternatives
2013 | 2013 @init {
2014 ( 2014 int stackSize = keepStackSize();
2015 { before(grammarAccess.getTypeScopeAccess().getIntegerTypeScopeParserRuleCall_2()); } 2015 }
2016 ruleIntegerTypeScope 2016:
2017 { after(grammarAccess.getTypeScopeAccess().getIntegerTypeScopeParserRuleCall_2()); } 2017 (
2018 ) 2018 { before(grammarAccess.getImportAccess().getEPackageImportParserRuleCall_0()); }
2019 | 2019 ruleEPackageImport
2020 ( 2020 { after(grammarAccess.getImportAccess().getEPackageImportParserRuleCall_0()); }
2021 { before(grammarAccess.getTypeScopeAccess().getRealTypeScopeParserRuleCall_3()); } 2021 )
2022 ruleRealTypeScope 2022 |
2023 { after(grammarAccess.getTypeScopeAccess().getRealTypeScopeParserRuleCall_3()); } 2023 (
2024 ) 2024 { before(grammarAccess.getImportAccess().getViatraImportParserRuleCall_1()); }
2025 | 2025 ruleViatraImport
2026 ( 2026 { after(grammarAccess.getImportAccess().getViatraImportParserRuleCall_1()); }
2027 { before(grammarAccess.getTypeScopeAccess().getStringTypeScopeParserRuleCall_4()); } 2027 )
2028 ruleStringTypeScope 2028 |
2029 { after(grammarAccess.getTypeScopeAccess().getStringTypeScopeParserRuleCall_4()); } 2029 (
2030 ) 2030 { before(grammarAccess.getImportAccess().getCftImportParserRuleCall_2()); }
2031; 2031 ruleCftImport
2032finally { 2032 { after(grammarAccess.getImportAccess().getCftImportParserRuleCall_2()); }
2033 restoreStackSize(stackSize); 2033 )
2034} 2034;
2035 2035finally {
2036rule__ClassTypeScope__Alternatives_2 2036 restoreStackSize(stackSize);
2037 @init { 2037}
2038 int stackSize = keepStackSize(); 2038
2039 } 2039rule__Declaration__Alternatives
2040: 2040 @init {
2041 ( 2041 int stackSize = keepStackSize();
2042 { before(grammarAccess.getClassTypeScopeAccess().getSetsNewAssignment_2_0()); } 2042 }
2043 (rule__ClassTypeScope__SetsNewAssignment_2_0) 2043:
2044 { after(grammarAccess.getClassTypeScopeAccess().getSetsNewAssignment_2_0()); } 2044 (
2045 ) 2045 { before(grammarAccess.getDeclarationAccess().getFileDeclarationParserRuleCall_0()); }
2046 | 2046 ruleFileDeclaration
2047 ( 2047 { after(grammarAccess.getDeclarationAccess().getFileDeclarationParserRuleCall_0()); }
2048 { before(grammarAccess.getClassTypeScopeAccess().getSetsSumAssignment_2_1()); } 2048 )
2049 (rule__ClassTypeScope__SetsSumAssignment_2_1) 2049 |
2050 { after(grammarAccess.getClassTypeScopeAccess().getSetsSumAssignment_2_1()); } 2050 (
2051 ) 2051 { before(grammarAccess.getDeclarationAccess().getMetamodelDeclarationParserRuleCall_1()); }
2052; 2052 ruleMetamodelDeclaration
2053finally { 2053 { after(grammarAccess.getDeclarationAccess().getMetamodelDeclarationParserRuleCall_1()); }
2054 restoreStackSize(stackSize); 2054 )
2055} 2055 |
2056 2056 (
2057rule__ClassTypeScope__Alternatives_3 2057 { before(grammarAccess.getDeclarationAccess().getPartialModelDeclarationParserRuleCall_2()); }
2058 @init { 2058 rulePartialModelDeclaration
2059 int stackSize = keepStackSize(); 2059 { after(grammarAccess.getDeclarationAccess().getPartialModelDeclarationParserRuleCall_2()); }
2060 } 2060 )
2061: 2061 |
2062 ( 2062 (
2063 { before(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_0()); } 2063 { before(grammarAccess.getDeclarationAccess().getGraphPatternDeclarationParserRuleCall_3()); }
2064 (rule__ClassTypeScope__NumberAssignment_3_0) 2064 ruleGraphPatternDeclaration
2065 { after(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_0()); } 2065 { after(grammarAccess.getDeclarationAccess().getGraphPatternDeclarationParserRuleCall_3()); }
2066 ) 2066 )
2067 | 2067 |
2068 ( 2068 (
2069 { before(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_1()); } 2069 { before(grammarAccess.getDeclarationAccess().getConfigDeclarationParserRuleCall_4()); }
2070 (rule__ClassTypeScope__NumberAssignment_3_1) 2070 ruleConfigDeclaration
2071 { after(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_1()); } 2071 { after(grammarAccess.getDeclarationAccess().getConfigDeclarationParserRuleCall_4()); }
2072 ) 2072 )
2073; 2073 |
2074finally { 2074 (
2075 restoreStackSize(stackSize); 2075 { before(grammarAccess.getDeclarationAccess().getScopeDeclarationParserRuleCall_5()); }
2076} 2076 ruleScopeDeclaration
2077 2077 { after(grammarAccess.getDeclarationAccess().getScopeDeclarationParserRuleCall_5()); }
2078rule__ObjectTypeScope__Alternatives_2 2078 )
2079 @init { 2079 |
2080 int stackSize = keepStackSize(); 2080 (
2081 } 2081 { before(grammarAccess.getDeclarationAccess().getObjectiveDeclarationParserRuleCall_6()); }
2082: 2082 ruleObjectiveDeclaration
2083 ( 2083 { after(grammarAccess.getDeclarationAccess().getObjectiveDeclarationParserRuleCall_6()); }
2084 { before(grammarAccess.getObjectTypeScopeAccess().getSetsNewAssignment_2_0()); } 2084 )
2085 (rule__ObjectTypeScope__SetsNewAssignment_2_0) 2085;
2086 { after(grammarAccess.getObjectTypeScopeAccess().getSetsNewAssignment_2_0()); } 2086finally {
2087 ) 2087 restoreStackSize(stackSize);
2088 | 2088}
2089 ( 2089
2090 { before(grammarAccess.getObjectTypeScopeAccess().getSetsSumAssignment_2_1()); } 2090rule__File__Alternatives
2091 (rule__ObjectTypeScope__SetsSumAssignment_2_1) 2091 @init {
2092 { after(grammarAccess.getObjectTypeScopeAccess().getSetsSumAssignment_2_1()); } 2092 int stackSize = keepStackSize();
2093 ) 2093 }
2094; 2094:
2095finally { 2095 (
2096 restoreStackSize(stackSize); 2096 { before(grammarAccess.getFileAccess().getFileSpecificationParserRuleCall_0()); }
2097} 2097 ruleFileSpecification
2098 2098 { after(grammarAccess.getFileAccess().getFileSpecificationParserRuleCall_0()); }
2099rule__ObjectTypeScope__Alternatives_3 2099 )
2100 @init { 2100 |
2101 int stackSize = keepStackSize(); 2101 (
2102 } 2102 { before(grammarAccess.getFileAccess().getFileReferenceParserRuleCall_1()); }
2103: 2103 ruleFileReference
2104 ( 2104 { after(grammarAccess.getFileAccess().getFileReferenceParserRuleCall_1()); }
2105 { before(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_0()); } 2105 )
2106 (rule__ObjectTypeScope__NumberAssignment_3_0) 2106;
2107 { after(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_0()); } 2107finally {
2108 ) 2108 restoreStackSize(stackSize);
2109 | 2109}
2110 ( 2110
2111 { before(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_1()); } 2111rule__MetamodelEntry__Alternatives
2112 (rule__ObjectTypeScope__NumberAssignment_3_1) 2112 @init {
2113 { after(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_1()); } 2113 int stackSize = keepStackSize();
2114 ) 2114 }
2115; 2115:
2116finally { 2116 (
2117 restoreStackSize(stackSize); 2117 { before(grammarAccess.getMetamodelEntryAccess().getMetamodelElementParserRuleCall_0()); }
2118} 2118 ruleMetamodelElement
2119 2119 { after(grammarAccess.getMetamodelEntryAccess().getMetamodelElementParserRuleCall_0()); }
2120rule__IntegerTypeScope__Alternatives_2 2120 )
2121 @init { 2121 |
2122 int stackSize = keepStackSize(); 2122 (
2123 } 2123 { before(grammarAccess.getMetamodelEntryAccess().getAllPackageEntryParserRuleCall_1()); }
2124: 2124 ruleAllPackageEntry
2125 ( 2125 { after(grammarAccess.getMetamodelEntryAccess().getAllPackageEntryParserRuleCall_1()); }
2126 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsNewAssignment_2_0()); } 2126 )
2127 (rule__IntegerTypeScope__SetsNewAssignment_2_0) 2127;
2128 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsNewAssignment_2_0()); } 2128finally {
2129 ) 2129 restoreStackSize(stackSize);
2130 | 2130}
2131 ( 2131
2132 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsSumAssignment_2_1()); } 2132rule__Metamodel__Alternatives
2133 (rule__IntegerTypeScope__SetsSumAssignment_2_1) 2133 @init {
2134 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsSumAssignment_2_1()); } 2134 int stackSize = keepStackSize();
2135 ) 2135 }
2136; 2136:
2137finally { 2137 (
2138 restoreStackSize(stackSize); 2138 { before(grammarAccess.getMetamodelAccess().getMetamodelReferenceParserRuleCall_0()); }
2139} 2139 ruleMetamodelReference
2140 2140 { after(grammarAccess.getMetamodelAccess().getMetamodelReferenceParserRuleCall_0()); }
2141rule__IntegerTypeScope__Alternatives_3 2141 )
2142 @init { 2142 |
2143 int stackSize = keepStackSize(); 2143 (
2144 } 2144 { before(grammarAccess.getMetamodelAccess().getMetamodelSpecificationParserRuleCall_1()); }
2145: 2145 ruleMetamodelSpecification
2146 ( 2146 { after(grammarAccess.getMetamodelAccess().getMetamodelSpecificationParserRuleCall_1()); }
2147 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_0()); } 2147 )
2148 (rule__IntegerTypeScope__NumberAssignment_3_0) 2148;
2149 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_0()); } 2149finally {
2150 ) 2150 restoreStackSize(stackSize);
2151 | 2151}
2152 ( 2152
2153 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_1()); } 2153rule__PartialModelEntry__Alternatives
2154 (rule__IntegerTypeScope__NumberAssignment_3_1) 2154 @init {
2155 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_1()); } 2155 int stackSize = keepStackSize();
2156 ) 2156 }
2157 | 2157:
2158 ( 2158 (
2159 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_2()); } 2159 { before(grammarAccess.getPartialModelEntryAccess().getModelEntryParserRuleCall_0()); }
2160 (rule__IntegerTypeScope__NumberAssignment_3_2) 2160 ruleModelEntry
2161 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_2()); } 2161 { after(grammarAccess.getPartialModelEntryAccess().getModelEntryParserRuleCall_0()); }
2162 ) 2162 )
2163; 2163 |
2164finally { 2164 (
2165 restoreStackSize(stackSize); 2165 { before(grammarAccess.getPartialModelEntryAccess().getFolderEntryParserRuleCall_1()); }
2166} 2166 ruleFolderEntry
2167 2167 { after(grammarAccess.getPartialModelEntryAccess().getFolderEntryParserRuleCall_1()); }
2168rule__RealTypeScope__Alternatives_2 2168 )
2169 @init { 2169;
2170 int stackSize = keepStackSize(); 2170finally {
2171 } 2171 restoreStackSize(stackSize);
2172: 2172}
2173 ( 2173
2174 { before(grammarAccess.getRealTypeScopeAccess().getSetsNewAssignment_2_0()); } 2174rule__PartialModel__Alternatives
2175 (rule__RealTypeScope__SetsNewAssignment_2_0) 2175 @init {
2176 { after(grammarAccess.getRealTypeScopeAccess().getSetsNewAssignment_2_0()); } 2176 int stackSize = keepStackSize();
2177 ) 2177 }
2178 | 2178:
2179 ( 2179 (
2180 { before(grammarAccess.getRealTypeScopeAccess().getSetsSumAssignment_2_1()); } 2180 { before(grammarAccess.getPartialModelAccess().getPartialModelSpecificationParserRuleCall_0()); }
2181 (rule__RealTypeScope__SetsSumAssignment_2_1) 2181 rulePartialModelSpecification
2182 { after(grammarAccess.getRealTypeScopeAccess().getSetsSumAssignment_2_1()); } 2182 { after(grammarAccess.getPartialModelAccess().getPartialModelSpecificationParserRuleCall_0()); }
2183 ) 2183 )
2184; 2184 |
2185finally { 2185 (
2186 restoreStackSize(stackSize); 2186 { before(grammarAccess.getPartialModelAccess().getPartialModelReferenceParserRuleCall_1()); }
2187} 2187 rulePartialModelReference
2188 2188 { after(grammarAccess.getPartialModelAccess().getPartialModelReferenceParserRuleCall_1()); }
2189rule__RealTypeScope__Alternatives_3 2189 )
2190 @init { 2190;
2191 int stackSize = keepStackSize(); 2191finally {
2192 } 2192 restoreStackSize(stackSize);
2193: 2193}
2194 ( 2194
2195 { before(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_0()); } 2195rule__PatternEntry__Alternatives
2196 (rule__RealTypeScope__NumberAssignment_3_0) 2196 @init {
2197 { after(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_0()); } 2197 int stackSize = keepStackSize();
2198 ) 2198 }
2199 | 2199:
2200 ( 2200 (
2201 { before(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_1()); } 2201 { before(grammarAccess.getPatternEntryAccess().getPatternElementParserRuleCall_0()); }
2202 (rule__RealTypeScope__NumberAssignment_3_1) 2202 rulePatternElement
2203 { after(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_1()); } 2203 { after(grammarAccess.getPatternEntryAccess().getPatternElementParserRuleCall_0()); }
2204 ) 2204 )
2205 | 2205 |
2206 ( 2206 (
2207 { before(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_2()); } 2207 { before(grammarAccess.getPatternEntryAccess().getAllPatternEntryParserRuleCall_1()); }
2208 (rule__RealTypeScope__NumberAssignment_3_2) 2208 ruleAllPatternEntry
2209 { after(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_2()); } 2209 { after(grammarAccess.getPatternEntryAccess().getAllPatternEntryParserRuleCall_1()); }
2210 ) 2210 )
2211; 2211;
2212finally { 2212finally {
2213 restoreStackSize(stackSize); 2213 restoreStackSize(stackSize);
2214} 2214}
2215 2215
2216rule__StringTypeScope__Alternatives_2 2216rule__GraphPattern__Alternatives
2217 @init { 2217 @init {
2218 int stackSize = keepStackSize(); 2218 int stackSize = keepStackSize();
2219 } 2219 }
2220: 2220:
2221 ( 2221 (
2222 { before(grammarAccess.getStringTypeScopeAccess().getSetsNewAssignment_2_0()); } 2222 { before(grammarAccess.getGraphPatternAccess().getGraphPatternReferenceParserRuleCall_0()); }
2223 (rule__StringTypeScope__SetsNewAssignment_2_0) 2223 ruleGraphPatternReference
2224 { after(grammarAccess.getStringTypeScopeAccess().getSetsNewAssignment_2_0()); } 2224 { after(grammarAccess.getGraphPatternAccess().getGraphPatternReferenceParserRuleCall_0()); }
2225 ) 2225 )
2226 | 2226 |
2227 ( 2227 (
2228 { before(grammarAccess.getStringTypeScopeAccess().getSetsSumAssignment_2_1()); } 2228 { before(grammarAccess.getGraphPatternAccess().getPatternSpecificationParserRuleCall_1()); }
2229 (rule__StringTypeScope__SetsSumAssignment_2_1) 2229 rulePatternSpecification
2230 { after(grammarAccess.getStringTypeScopeAccess().getSetsSumAssignment_2_1()); } 2230 { after(grammarAccess.getGraphPatternAccess().getPatternSpecificationParserRuleCall_1()); }
2231 ) 2231 )
2232; 2232;
2233finally { 2233finally {
2234 restoreStackSize(stackSize); 2234 restoreStackSize(stackSize);
2235} 2235}
2236 2236
2237rule__StringTypeScope__Alternatives_3 2237rule__ObjectiveEntry__Alternatives
2238 @init { 2238 @init {
2239 int stackSize = keepStackSize(); 2239 int stackSize = keepStackSize();
2240 } 2240 }
2241: 2241:
2242 ( 2242 (
2243 { before(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_0()); } 2243 { before(grammarAccess.getObjectiveEntryAccess().getOptimizationEntryParserRuleCall_0()); }
2244 (rule__StringTypeScope__NumberAssignment_3_0) 2244 ruleOptimizationEntry
2245 { after(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_0()); } 2245 { after(grammarAccess.getObjectiveEntryAccess().getOptimizationEntryParserRuleCall_0()); }
2246 ) 2246 )
2247 | 2247 |
2248 ( 2248 (
2249 { before(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_1()); } 2249 { before(grammarAccess.getObjectiveEntryAccess().getThresholdEntryParserRuleCall_1()); }
2250 (rule__StringTypeScope__NumberAssignment_3_1) 2250 ruleThresholdEntry
2251 { after(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_1()); } 2251 { after(grammarAccess.getObjectiveEntryAccess().getThresholdEntryParserRuleCall_1()); }
2252 ) 2252 )
2253 | 2253;
2254 ( 2254finally {
2255 { before(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_2()); } 2255 restoreStackSize(stackSize);
2256 (rule__StringTypeScope__NumberAssignment_3_2) 2256}
2257 { after(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_2()); } 2257
2258 ) 2258rule__Objective__Alternatives
2259; 2259 @init {
2260finally { 2260 int stackSize = keepStackSize();
2261 restoreStackSize(stackSize); 2261 }
2262} 2262:
2263 2263 (
2264rule__ExactNumber__Alternatives 2264 { before(grammarAccess.getObjectiveAccess().getObjectiveReferenceParserRuleCall_0()); }
2265 @init { 2265 ruleObjectiveReference
2266 int stackSize = keepStackSize(); 2266 { after(grammarAccess.getObjectiveAccess().getObjectiveReferenceParserRuleCall_0()); }
2267 } 2267 )
2268: 2268 |
2269 ( 2269 (
2270 { before(grammarAccess.getExactNumberAccess().getExactNumberAssignment_0()); } 2270 { before(grammarAccess.getObjectiveAccess().getObjectiveSpecificationParserRuleCall_1()); }
2271 (rule__ExactNumber__ExactNumberAssignment_0) 2271 ruleObjectiveSpecification
2272 { after(grammarAccess.getExactNumberAccess().getExactNumberAssignment_0()); } 2272 { after(grammarAccess.getObjectiveAccess().getObjectiveSpecificationParserRuleCall_1()); }
2273 ) 2273 )
2274 | 2274;
2275 ( 2275finally {
2276 { before(grammarAccess.getExactNumberAccess().getExactUnlimitedAssignment_1()); } 2276 restoreStackSize(stackSize);
2277 (rule__ExactNumber__ExactUnlimitedAssignment_1) 2277}
2278 { after(grammarAccess.getExactNumberAccess().getExactUnlimitedAssignment_1()); } 2278
2279 ) 2279rule__ConfigEntry__Alternatives
2280; 2280 @init {
2281finally { 2281 int stackSize = keepStackSize();
2282 restoreStackSize(stackSize); 2282 }
2283} 2283:
2284 2284 (
2285rule__IntervallNumber__Alternatives_2 2285 { before(grammarAccess.getConfigEntryAccess().getDocumentationEntryParserRuleCall_0()); }
2286 @init { 2286 ruleDocumentationEntry
2287 int stackSize = keepStackSize(); 2287 { after(grammarAccess.getConfigEntryAccess().getDocumentationEntryParserRuleCall_0()); }
2288 } 2288 )
2289: 2289 |
2290 ( 2290 (
2291 { before(grammarAccess.getIntervallNumberAccess().getMaxNumberAssignment_2_0()); } 2291 { before(grammarAccess.getConfigEntryAccess().getRuntimeEntryParserRuleCall_1()); }
2292 (rule__IntervallNumber__MaxNumberAssignment_2_0) 2292 ruleRuntimeEntry
2293 { after(grammarAccess.getIntervallNumberAccess().getMaxNumberAssignment_2_0()); } 2293 { after(grammarAccess.getConfigEntryAccess().getRuntimeEntryParserRuleCall_1()); }
2294 ) 2294 )
2295 | 2295 |
2296 ( 2296 (
2297 { before(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAssignment_2_1()); } 2297 { before(grammarAccess.getConfigEntryAccess().getMemoryEntryParserRuleCall_2()); }
2298 (rule__IntervallNumber__MaxUnlimitedAssignment_2_1) 2298 ruleMemoryEntry
2299 { after(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAssignment_2_1()); } 2299 { after(grammarAccess.getConfigEntryAccess().getMemoryEntryParserRuleCall_2()); }
2300 ) 2300 )
2301; 2301 |
2302finally { 2302 (
2303 restoreStackSize(stackSize); 2303 { before(grammarAccess.getConfigEntryAccess().getCustomEntryParserRuleCall_3()); }
2304} 2304 ruleCustomEntry
2305 2305 { after(grammarAccess.getConfigEntryAccess().getCustomEntryParserRuleCall_3()); }
2306rule__Scope__Alternatives 2306 )
2307 @init { 2307;
2308 int stackSize = keepStackSize(); 2308finally {
2309 } 2309 restoreStackSize(stackSize);
2310: 2310}
2311 ( 2311
2312 { before(grammarAccess.getScopeAccess().getScopeSpecificationParserRuleCall_0()); } 2312rule__Config__Alternatives
2313 ruleScopeSpecification 2313 @init {
2314 { after(grammarAccess.getScopeAccess().getScopeSpecificationParserRuleCall_0()); } 2314 int stackSize = keepStackSize();
2315 ) 2315 }
2316 | 2316:
2317 ( 2317 (
2318 { before(grammarAccess.getScopeAccess().getScopeReferenceParserRuleCall_1()); } 2318 { before(grammarAccess.getConfigAccess().getConfigSpecificationParserRuleCall_0()); }
2319 ruleScopeReference 2319 ruleConfigSpecification
2320 { after(grammarAccess.getScopeAccess().getScopeReferenceParserRuleCall_1()); } 2320 { after(grammarAccess.getConfigAccess().getConfigSpecificationParserRuleCall_0()); }
2321 ) 2321 )
2322; 2322 |
2323finally { 2323 (
2324 restoreStackSize(stackSize); 2324 { before(grammarAccess.getConfigAccess().getConfigReferenceParserRuleCall_1()); }
2325} 2325 ruleConfigReference
2326 2326 { after(grammarAccess.getConfigAccess().getConfigReferenceParserRuleCall_1()); }
2327rule__DocumentLevelSpecification__Alternatives 2327 )
2328 @init { 2328;
2329 int stackSize = keepStackSize(); 2329finally {
2330 } 2330 restoreStackSize(stackSize);
2331: 2331}
2332 ( 2332
2333 { before(grammarAccess.getDocumentLevelSpecificationAccess().getNoneEnumLiteralDeclaration_0()); } 2333rule__TypeScope__Alternatives
2334 ('none') 2334 @init {
2335 { after(grammarAccess.getDocumentLevelSpecificationAccess().getNoneEnumLiteralDeclaration_0()); } 2335 int stackSize = keepStackSize();
2336 ) 2336 }
2337 | 2337:
2338 ( 2338 (
2339 { before(grammarAccess.getDocumentLevelSpecificationAccess().getNormalEnumLiteralDeclaration_1()); } 2339 { before(grammarAccess.getTypeScopeAccess().getClassTypeScopeParserRuleCall_0()); }
2340 ('normal') 2340 ruleClassTypeScope
2341 { after(grammarAccess.getDocumentLevelSpecificationAccess().getNormalEnumLiteralDeclaration_1()); } 2341 { after(grammarAccess.getTypeScopeAccess().getClassTypeScopeParserRuleCall_0()); }
2342 ) 2342 )
2343 | 2343 |
2344 ( 2344 (
2345 { before(grammarAccess.getDocumentLevelSpecificationAccess().getFullEnumLiteralDeclaration_2()); } 2345 { before(grammarAccess.getTypeScopeAccess().getObjectTypeScopeParserRuleCall_1()); }
2346 ('full') 2346 ruleObjectTypeScope
2347 { after(grammarAccess.getDocumentLevelSpecificationAccess().getFullEnumLiteralDeclaration_2()); } 2347 { after(grammarAccess.getTypeScopeAccess().getObjectTypeScopeParserRuleCall_1()); }
2348 ) 2348 )
2349; 2349 |
2350finally { 2350 (
2351 restoreStackSize(stackSize); 2351 { before(grammarAccess.getTypeScopeAccess().getIntegerTypeScopeParserRuleCall_2()); }
2352} 2352 ruleIntegerTypeScope
2353 2353 { after(grammarAccess.getTypeScopeAccess().getIntegerTypeScopeParserRuleCall_2()); }
2354rule__Solver__Alternatives 2354 )
2355 @init { 2355 |
2356 int stackSize = keepStackSize(); 2356 (
2357 } 2357 { before(grammarAccess.getTypeScopeAccess().getRealTypeScopeParserRuleCall_3()); }
2358: 2358 ruleRealTypeScope
2359 ( 2359 { after(grammarAccess.getTypeScopeAccess().getRealTypeScopeParserRuleCall_3()); }
2360 { before(grammarAccess.getSolverAccess().getSMTSolverEnumLiteralDeclaration_0()); } 2360 )
2361 ('SMTSolver') 2361 |
2362 { after(grammarAccess.getSolverAccess().getSMTSolverEnumLiteralDeclaration_0()); } 2362 (
2363 ) 2363 { before(grammarAccess.getTypeScopeAccess().getStringTypeScopeParserRuleCall_4()); }
2364 | 2364 ruleStringTypeScope
2365 ( 2365 { after(grammarAccess.getTypeScopeAccess().getStringTypeScopeParserRuleCall_4()); }
2366 { before(grammarAccess.getSolverAccess().getAlloySolverEnumLiteralDeclaration_1()); } 2366 )
2367 ('AlloySolver') 2367;
2368 { after(grammarAccess.getSolverAccess().getAlloySolverEnumLiteralDeclaration_1()); } 2368finally {
2369 ) 2369 restoreStackSize(stackSize);
2370 | 2370}
2371 ( 2371
2372 { before(grammarAccess.getSolverAccess().getViatraSolverEnumLiteralDeclaration_2()); } 2372rule__ClassTypeScope__Alternatives_2
2373 ('ViatraSolver') 2373 @init {
2374 { after(grammarAccess.getSolverAccess().getViatraSolverEnumLiteralDeclaration_2()); } 2374 int stackSize = keepStackSize();
2375 ) 2375 }
2376; 2376:
2377finally { 2377 (
2378 restoreStackSize(stackSize); 2378 { before(grammarAccess.getClassTypeScopeAccess().getSetsNewAssignment_2_0()); }
2379} 2379 (rule__ClassTypeScope__SetsNewAssignment_2_0)
2380 2380 { after(grammarAccess.getClassTypeScopeAccess().getSetsNewAssignment_2_0()); }
2381rule__ConfigurationScript__Group__0 2381 )
2382 @init { 2382 |
2383 int stackSize = keepStackSize(); 2383 (
2384 } 2384 { before(grammarAccess.getClassTypeScopeAccess().getSetsSumAssignment_2_1()); }
2385: 2385 (rule__ClassTypeScope__SetsSumAssignment_2_1)
2386 rule__ConfigurationScript__Group__0__Impl 2386 { after(grammarAccess.getClassTypeScopeAccess().getSetsSumAssignment_2_1()); }
2387 rule__ConfigurationScript__Group__1 2387 )
2388; 2388;
2389finally { 2389finally {
2390 restoreStackSize(stackSize); 2390 restoreStackSize(stackSize);
2391} 2391}
2392 2392
2393rule__ConfigurationScript__Group__0__Impl 2393rule__ClassTypeScope__Alternatives_3
2394 @init { 2394 @init {
2395 int stackSize = keepStackSize(); 2395 int stackSize = keepStackSize();
2396 } 2396 }
2397: 2397:
2398( 2398 (
2399 { before(grammarAccess.getConfigurationScriptAccess().getImportsAssignment_0()); } 2399 { before(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_0()); }
2400 (rule__ConfigurationScript__ImportsAssignment_0)* 2400 (rule__ClassTypeScope__NumberAssignment_3_0)
2401 { after(grammarAccess.getConfigurationScriptAccess().getImportsAssignment_0()); } 2401 { after(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_0()); }
2402) 2402 )
2403; 2403 |
2404finally { 2404 (
2405 restoreStackSize(stackSize); 2405 { before(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_1()); }
2406} 2406 (rule__ClassTypeScope__NumberAssignment_3_1)
2407 2407 { after(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_1()); }
2408rule__ConfigurationScript__Group__1 2408 )
2409 @init { 2409;
2410 int stackSize = keepStackSize(); 2410finally {
2411 } 2411 restoreStackSize(stackSize);
2412: 2412}
2413 rule__ConfigurationScript__Group__1__Impl 2413
2414; 2414rule__ObjectTypeScope__Alternatives_2
2415finally { 2415 @init {
2416 restoreStackSize(stackSize); 2416 int stackSize = keepStackSize();
2417} 2417 }
2418 2418:
2419rule__ConfigurationScript__Group__1__Impl 2419 (
2420 @init { 2420 { before(grammarAccess.getObjectTypeScopeAccess().getSetsNewAssignment_2_0()); }
2421 int stackSize = keepStackSize(); 2421 (rule__ObjectTypeScope__SetsNewAssignment_2_0)
2422 } 2422 { after(grammarAccess.getObjectTypeScopeAccess().getSetsNewAssignment_2_0()); }
2423: 2423 )
2424( 2424 |
2425 { before(grammarAccess.getConfigurationScriptAccess().getCommandsAssignment_1()); } 2425 (
2426 (rule__ConfigurationScript__CommandsAssignment_1)* 2426 { before(grammarAccess.getObjectTypeScopeAccess().getSetsSumAssignment_2_1()); }
2427 { after(grammarAccess.getConfigurationScriptAccess().getCommandsAssignment_1()); } 2427 (rule__ObjectTypeScope__SetsSumAssignment_2_1)
2428) 2428 { after(grammarAccess.getObjectTypeScopeAccess().getSetsSumAssignment_2_1()); }
2429; 2429 )
2430finally { 2430;
2431 restoreStackSize(stackSize); 2431finally {
2432} 2432 restoreStackSize(stackSize);
2433 2433}
2434 2434
2435rule__QualifiedName__Group__0 2435rule__ObjectTypeScope__Alternatives_3
2436 @init { 2436 @init {
2437 int stackSize = keepStackSize(); 2437 int stackSize = keepStackSize();
2438 } 2438 }
2439: 2439:
2440 rule__QualifiedName__Group__0__Impl 2440 (
2441 rule__QualifiedName__Group__1 2441 { before(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_0()); }
2442; 2442 (rule__ObjectTypeScope__NumberAssignment_3_0)
2443finally { 2443 { after(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_0()); }
2444 restoreStackSize(stackSize); 2444 )
2445} 2445 |
2446 2446 (
2447rule__QualifiedName__Group__0__Impl 2447 { before(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_1()); }
2448 @init { 2448 (rule__ObjectTypeScope__NumberAssignment_3_1)
2449 int stackSize = keepStackSize(); 2449 { after(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_1()); }
2450 } 2450 )
2451: 2451;
2452( 2452finally {
2453 { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); } 2453 restoreStackSize(stackSize);
2454 RULE_ID 2454}
2455 { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); } 2455
2456) 2456rule__IntegerTypeScope__Alternatives_2
2457; 2457 @init {
2458finally { 2458 int stackSize = keepStackSize();
2459 restoreStackSize(stackSize); 2459 }
2460} 2460:
2461 2461 (
2462rule__QualifiedName__Group__1 2462 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsNewAssignment_2_0()); }
2463 @init { 2463 (rule__IntegerTypeScope__SetsNewAssignment_2_0)
2464 int stackSize = keepStackSize(); 2464 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsNewAssignment_2_0()); }
2465 } 2465 )
2466: 2466 |
2467 rule__QualifiedName__Group__1__Impl 2467 (
2468; 2468 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsSumAssignment_2_1()); }
2469finally { 2469 (rule__IntegerTypeScope__SetsSumAssignment_2_1)
2470 restoreStackSize(stackSize); 2470 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsSumAssignment_2_1()); }
2471} 2471 )
2472 2472;
2473rule__QualifiedName__Group__1__Impl 2473finally {
2474 @init { 2474 restoreStackSize(stackSize);
2475 int stackSize = keepStackSize(); 2475}
2476 } 2476
2477: 2477rule__IntegerTypeScope__Alternatives_3
2478( 2478 @init {
2479 { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); } 2479 int stackSize = keepStackSize();
2480 (rule__QualifiedName__Group_1__0)* 2480 }
2481 { after(grammarAccess.getQualifiedNameAccess().getGroup_1()); } 2481:
2482) 2482 (
2483; 2483 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_0()); }
2484finally { 2484 (rule__IntegerTypeScope__NumberAssignment_3_0)
2485 restoreStackSize(stackSize); 2485 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_0()); }
2486} 2486 )
2487 2487 |
2488 2488 (
2489rule__QualifiedName__Group_1__0 2489 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_1()); }
2490 @init { 2490 (rule__IntegerTypeScope__NumberAssignment_3_1)
2491 int stackSize = keepStackSize(); 2491 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_1()); }
2492 } 2492 )
2493: 2493 |
2494 rule__QualifiedName__Group_1__0__Impl 2494 (
2495 rule__QualifiedName__Group_1__1 2495 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_2()); }
2496; 2496 (rule__IntegerTypeScope__NumberAssignment_3_2)
2497finally { 2497 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_2()); }
2498 restoreStackSize(stackSize); 2498 )
2499} 2499;
2500 2500finally {
2501rule__QualifiedName__Group_1__0__Impl 2501 restoreStackSize(stackSize);
2502 @init { 2502}
2503 int stackSize = keepStackSize(); 2503
2504 } 2504rule__RealTypeScope__Alternatives_2
2505: 2505 @init {
2506( 2506 int stackSize = keepStackSize();
2507 { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); } 2507 }
2508 '.' 2508:
2509 { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); } 2509 (
2510) 2510 { before(grammarAccess.getRealTypeScopeAccess().getSetsNewAssignment_2_0()); }
2511; 2511 (rule__RealTypeScope__SetsNewAssignment_2_0)
2512finally { 2512 { after(grammarAccess.getRealTypeScopeAccess().getSetsNewAssignment_2_0()); }
2513 restoreStackSize(stackSize); 2513 )
2514} 2514 |
2515 2515 (
2516rule__QualifiedName__Group_1__1 2516 { before(grammarAccess.getRealTypeScopeAccess().getSetsSumAssignment_2_1()); }
2517 @init { 2517 (rule__RealTypeScope__SetsSumAssignment_2_1)
2518 int stackSize = keepStackSize(); 2518 { after(grammarAccess.getRealTypeScopeAccess().getSetsSumAssignment_2_1()); }
2519 } 2519 )
2520: 2520;
2521 rule__QualifiedName__Group_1__1__Impl 2521finally {
2522; 2522 restoreStackSize(stackSize);
2523finally { 2523}
2524 restoreStackSize(stackSize); 2524
2525} 2525rule__RealTypeScope__Alternatives_3
2526 2526 @init {
2527rule__QualifiedName__Group_1__1__Impl 2527 int stackSize = keepStackSize();
2528 @init { 2528 }
2529 int stackSize = keepStackSize(); 2529:
2530 } 2530 (
2531: 2531 { before(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_0()); }
2532( 2532 (rule__RealTypeScope__NumberAssignment_3_0)
2533 { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); } 2533 { after(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_0()); }
2534 RULE_ID 2534 )
2535 { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); } 2535 |
2536) 2536 (
2537; 2537 { before(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_1()); }
2538finally { 2538 (rule__RealTypeScope__NumberAssignment_3_1)
2539 restoreStackSize(stackSize); 2539 { after(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_1()); }
2540} 2540 )
2541 2541 |
2542 2542 (
2543rule__REALLiteral__Group__0 2543 { before(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_2()); }
2544 @init { 2544 (rule__RealTypeScope__NumberAssignment_3_2)
2545 int stackSize = keepStackSize(); 2545 { after(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_2()); }
2546 } 2546 )
2547: 2547;
2548 rule__REALLiteral__Group__0__Impl 2548finally {
2549 rule__REALLiteral__Group__1 2549 restoreStackSize(stackSize);
2550; 2550}
2551finally { 2551
2552 restoreStackSize(stackSize); 2552rule__StringTypeScope__Alternatives_2
2553} 2553 @init {
2554 2554 int stackSize = keepStackSize();
2555rule__REALLiteral__Group__0__Impl 2555 }
2556 @init { 2556:
2557 int stackSize = keepStackSize(); 2557 (
2558 } 2558 { before(grammarAccess.getStringTypeScopeAccess().getSetsNewAssignment_2_0()); }
2559: 2559 (rule__StringTypeScope__SetsNewAssignment_2_0)
2560( 2560 { after(grammarAccess.getStringTypeScopeAccess().getSetsNewAssignment_2_0()); }
2561 { before(grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); } 2561 )
2562 ('-')? 2562 |
2563 { after(grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); } 2563 (
2564) 2564 { before(grammarAccess.getStringTypeScopeAccess().getSetsSumAssignment_2_1()); }
2565; 2565 (rule__StringTypeScope__SetsSumAssignment_2_1)
2566finally { 2566 { after(grammarAccess.getStringTypeScopeAccess().getSetsSumAssignment_2_1()); }
2567 restoreStackSize(stackSize); 2567 )
2568} 2568;
2569 2569finally {
2570rule__REALLiteral__Group__1 2570 restoreStackSize(stackSize);
2571 @init { 2571}
2572 int stackSize = keepStackSize(); 2572
2573 } 2573rule__StringTypeScope__Alternatives_3
2574: 2574 @init {
2575 rule__REALLiteral__Group__1__Impl 2575 int stackSize = keepStackSize();
2576 rule__REALLiteral__Group__2 2576 }
2577; 2577:
2578finally { 2578 (
2579 restoreStackSize(stackSize); 2579 { before(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_0()); }
2580} 2580 (rule__StringTypeScope__NumberAssignment_3_0)
2581 2581 { after(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_0()); }
2582rule__REALLiteral__Group__1__Impl 2582 )
2583 @init { 2583 |
2584 int stackSize = keepStackSize(); 2584 (
2585 } 2585 { before(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_1()); }
2586: 2586 (rule__StringTypeScope__NumberAssignment_3_1)
2587( 2587 { after(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_1()); }
2588 { before(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); } 2588 )
2589 RULE_INT 2589 |
2590 { after(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); } 2590 (
2591) 2591 { before(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_2()); }
2592; 2592 (rule__StringTypeScope__NumberAssignment_3_2)
2593finally { 2593 { after(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_2()); }
2594 restoreStackSize(stackSize); 2594 )
2595} 2595;
2596 2596finally {
2597rule__REALLiteral__Group__2 2597 restoreStackSize(stackSize);
2598 @init { 2598}
2599 int stackSize = keepStackSize(); 2599
2600 } 2600rule__ExactNumber__Alternatives
2601: 2601 @init {
2602 rule__REALLiteral__Group__2__Impl 2602 int stackSize = keepStackSize();
2603 rule__REALLiteral__Group__3 2603 }
2604; 2604:
2605finally { 2605 (
2606 restoreStackSize(stackSize); 2606 { before(grammarAccess.getExactNumberAccess().getExactNumberAssignment_0()); }
2607} 2607 (rule__ExactNumber__ExactNumberAssignment_0)
2608 2608 { after(grammarAccess.getExactNumberAccess().getExactNumberAssignment_0()); }
2609rule__REALLiteral__Group__2__Impl 2609 )
2610 @init { 2610 |
2611 int stackSize = keepStackSize(); 2611 (
2612 } 2612 { before(grammarAccess.getExactNumberAccess().getExactUnlimitedAssignment_1()); }
2613: 2613 (rule__ExactNumber__ExactUnlimitedAssignment_1)
2614( 2614 { after(grammarAccess.getExactNumberAccess().getExactUnlimitedAssignment_1()); }
2615 { before(grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); } 2615 )
2616 '.' 2616;
2617 { after(grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); } 2617finally {
2618) 2618 restoreStackSize(stackSize);
2619; 2619}
2620finally { 2620
2621 restoreStackSize(stackSize); 2621rule__IntervallNumber__Alternatives_2
2622} 2622 @init {
2623 2623 int stackSize = keepStackSize();
2624rule__REALLiteral__Group__3 2624 }
2625 @init { 2625:
2626 int stackSize = keepStackSize(); 2626 (
2627 } 2627 { before(grammarAccess.getIntervallNumberAccess().getMaxNumberAssignment_2_0()); }
2628: 2628 (rule__IntervallNumber__MaxNumberAssignment_2_0)
2629 rule__REALLiteral__Group__3__Impl 2629 { after(grammarAccess.getIntervallNumberAccess().getMaxNumberAssignment_2_0()); }
2630; 2630 )
2631finally { 2631 |
2632 restoreStackSize(stackSize); 2632 (
2633} 2633 { before(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAssignment_2_1()); }
2634 2634 (rule__IntervallNumber__MaxUnlimitedAssignment_2_1)
2635rule__REALLiteral__Group__3__Impl 2635 { after(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAssignment_2_1()); }
2636 @init { 2636 )
2637 int stackSize = keepStackSize(); 2637;
2638 } 2638finally {
2639: 2639 restoreStackSize(stackSize);
2640( 2640}
2641 { before(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); } 2641
2642 RULE_INT 2642rule__Scope__Alternatives
2643 { after(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); } 2643 @init {
2644) 2644 int stackSize = keepStackSize();
2645; 2645 }
2646finally { 2646:
2647 restoreStackSize(stackSize); 2647 (
2648} 2648 { before(grammarAccess.getScopeAccess().getScopeSpecificationParserRuleCall_0()); }
2649 2649 ruleScopeSpecification
2650 2650 { after(grammarAccess.getScopeAccess().getScopeSpecificationParserRuleCall_0()); }
2651rule__INTLiteral__Group__0 2651 )
2652 @init { 2652 |
2653 int stackSize = keepStackSize(); 2653 (
2654 } 2654 { before(grammarAccess.getScopeAccess().getScopeReferenceParserRuleCall_1()); }
2655: 2655 ruleScopeReference
2656 rule__INTLiteral__Group__0__Impl 2656 { after(grammarAccess.getScopeAccess().getScopeReferenceParserRuleCall_1()); }
2657 rule__INTLiteral__Group__1 2657 )
2658; 2658;
2659finally { 2659finally {
2660 restoreStackSize(stackSize); 2660 restoreStackSize(stackSize);
2661} 2661}
2662 2662
2663rule__INTLiteral__Group__0__Impl 2663rule__OptimizationDirection__Alternatives
2664 @init { 2664 @init {
2665 int stackSize = keepStackSize(); 2665 int stackSize = keepStackSize();
2666 } 2666 }
2667: 2667:
2668( 2668 (
2669 { before(grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); } 2669 { before(grammarAccess.getOptimizationDirectionAccess().getMINIMIZEEnumLiteralDeclaration_0()); }
2670 ('-')? 2670 ('minimize')
2671 { after(grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); } 2671 { after(grammarAccess.getOptimizationDirectionAccess().getMINIMIZEEnumLiteralDeclaration_0()); }
2672) 2672 )
2673; 2673 |
2674finally { 2674 (
2675 restoreStackSize(stackSize); 2675 { before(grammarAccess.getOptimizationDirectionAccess().getMAXIMIZEEnumLiteralDeclaration_1()); }
2676} 2676 ('maximize')
2677 2677 { after(grammarAccess.getOptimizationDirectionAccess().getMAXIMIZEEnumLiteralDeclaration_1()); }
2678rule__INTLiteral__Group__1 2678 )
2679 @init { 2679;
2680 int stackSize = keepStackSize(); 2680finally {
2681 } 2681 restoreStackSize(stackSize);
2682: 2682}
2683 rule__INTLiteral__Group__1__Impl 2683
2684; 2684rule__ComparisonOperator__Alternatives
2685finally { 2685 @init {
2686 restoreStackSize(stackSize); 2686 int stackSize = keepStackSize();
2687} 2687 }
2688 2688:
2689rule__INTLiteral__Group__1__Impl 2689 (
2690 @init { 2690 { before(grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_0()); }
2691 int stackSize = keepStackSize(); 2691 ('<=')
2692 } 2692 { after(grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_0()); }
2693: 2693 )
2694( 2694 |
2695 { before(grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); } 2695 (
2696 RULE_INT 2696 { before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_1()); }
2697 { after(grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); } 2697 ('>=')
2698) 2698 { after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_1()); }
2699; 2699 )
2700finally { 2700;
2701 restoreStackSize(stackSize); 2701finally {
2702} 2702 restoreStackSize(stackSize);
2703 2703}
2704 2704
2705rule__EPackageImport__Group__0 2705rule__DocumentLevelSpecification__Alternatives
2706 @init { 2706 @init {
2707 int stackSize = keepStackSize(); 2707 int stackSize = keepStackSize();
2708 } 2708 }
2709: 2709:
2710 rule__EPackageImport__Group__0__Impl 2710 (
2711 rule__EPackageImport__Group__1 2711 { before(grammarAccess.getDocumentLevelSpecificationAccess().getNoneEnumLiteralDeclaration_0()); }
2712; 2712 ('none')
2713finally { 2713 { after(grammarAccess.getDocumentLevelSpecificationAccess().getNoneEnumLiteralDeclaration_0()); }
2714 restoreStackSize(stackSize); 2714 )
2715} 2715 |
2716 2716 (
2717rule__EPackageImport__Group__0__Impl 2717 { before(grammarAccess.getDocumentLevelSpecificationAccess().getNormalEnumLiteralDeclaration_1()); }
2718 @init { 2718 ('normal')
2719 int stackSize = keepStackSize(); 2719 { after(grammarAccess.getDocumentLevelSpecificationAccess().getNormalEnumLiteralDeclaration_1()); }
2720 } 2720 )
2721: 2721 |
2722( 2722 (
2723 { before(grammarAccess.getEPackageImportAccess().getImportKeyword_0()); } 2723 { before(grammarAccess.getDocumentLevelSpecificationAccess().getFullEnumLiteralDeclaration_2()); }
2724 'import' 2724 ('full')
2725 { after(grammarAccess.getEPackageImportAccess().getImportKeyword_0()); } 2725 { after(grammarAccess.getDocumentLevelSpecificationAccess().getFullEnumLiteralDeclaration_2()); }
2726) 2726 )
2727; 2727;
2728finally { 2728finally {
2729 restoreStackSize(stackSize); 2729 restoreStackSize(stackSize);
2730} 2730}
2731 2731
2732rule__EPackageImport__Group__1 2732rule__Solver__Alternatives
2733 @init { 2733 @init {
2734 int stackSize = keepStackSize(); 2734 int stackSize = keepStackSize();
2735 } 2735 }
2736: 2736:
2737 rule__EPackageImport__Group__1__Impl 2737 (
2738 rule__EPackageImport__Group__2 2738 { before(grammarAccess.getSolverAccess().getSMTSolverEnumLiteralDeclaration_0()); }
2739; 2739 ('SMTSolver')
2740finally { 2740 { after(grammarAccess.getSolverAccess().getSMTSolverEnumLiteralDeclaration_0()); }
2741 restoreStackSize(stackSize); 2741 )
2742} 2742 |
2743 2743 (
2744rule__EPackageImport__Group__1__Impl 2744 { before(grammarAccess.getSolverAccess().getAlloySolverEnumLiteralDeclaration_1()); }
2745 @init { 2745 ('AlloySolver')
2746 int stackSize = keepStackSize(); 2746 { after(grammarAccess.getSolverAccess().getAlloySolverEnumLiteralDeclaration_1()); }
2747 } 2747 )
2748: 2748 |
2749( 2749 (
2750 { before(grammarAccess.getEPackageImportAccess().getEpackageKeyword_1()); } 2750 { before(grammarAccess.getSolverAccess().getViatraSolverEnumLiteralDeclaration_2()); }
2751 'epackage' 2751 ('ViatraSolver')
2752 { after(grammarAccess.getEPackageImportAccess().getEpackageKeyword_1()); } 2752 { after(grammarAccess.getSolverAccess().getViatraSolverEnumLiteralDeclaration_2()); }
2753) 2753 )
2754; 2754;
2755finally { 2755finally {
2756 restoreStackSize(stackSize); 2756 restoreStackSize(stackSize);
2757} 2757}
2758 2758
2759rule__EPackageImport__Group__2 2759rule__ConfigurationScript__Group__0
2760 @init { 2760 @init {
2761 int stackSize = keepStackSize(); 2761 int stackSize = keepStackSize();
2762 } 2762 }
2763: 2763:
2764 rule__EPackageImport__Group__2__Impl 2764 rule__ConfigurationScript__Group__0__Impl
2765; 2765 rule__ConfigurationScript__Group__1
2766finally { 2766;
2767 restoreStackSize(stackSize); 2767finally {
2768} 2768 restoreStackSize(stackSize);
2769 2769}
2770rule__EPackageImport__Group__2__Impl 2770
2771 @init { 2771rule__ConfigurationScript__Group__0__Impl
2772 int stackSize = keepStackSize(); 2772 @init {
2773 } 2773 int stackSize = keepStackSize();
2774: 2774 }
2775( 2775:
2776 { before(grammarAccess.getEPackageImportAccess().getImportedPackageAssignment_2()); } 2776(
2777 (rule__EPackageImport__ImportedPackageAssignment_2) 2777 { before(grammarAccess.getConfigurationScriptAccess().getImportsAssignment_0()); }
2778 { after(grammarAccess.getEPackageImportAccess().getImportedPackageAssignment_2()); } 2778 (rule__ConfigurationScript__ImportsAssignment_0)*
2779) 2779 { after(grammarAccess.getConfigurationScriptAccess().getImportsAssignment_0()); }
2780; 2780)
2781finally { 2781;
2782 restoreStackSize(stackSize); 2782finally {
2783} 2783 restoreStackSize(stackSize);
2784 2784}
2785 2785
2786rule__ViatraImport__Group__0 2786rule__ConfigurationScript__Group__1
2787 @init { 2787 @init {
2788 int stackSize = keepStackSize(); 2788 int stackSize = keepStackSize();
2789 } 2789 }
2790: 2790:
2791 rule__ViatraImport__Group__0__Impl 2791 rule__ConfigurationScript__Group__1__Impl
2792 rule__ViatraImport__Group__1 2792;
2793; 2793finally {
2794finally { 2794 restoreStackSize(stackSize);
2795 restoreStackSize(stackSize); 2795}
2796} 2796
2797 2797rule__ConfigurationScript__Group__1__Impl
2798rule__ViatraImport__Group__0__Impl 2798 @init {
2799 @init { 2799 int stackSize = keepStackSize();
2800 int stackSize = keepStackSize(); 2800 }
2801 } 2801:
2802: 2802(
2803( 2803 { before(grammarAccess.getConfigurationScriptAccess().getCommandsAssignment_1()); }
2804 { before(grammarAccess.getViatraImportAccess().getImportKeyword_0()); } 2804 (rule__ConfigurationScript__CommandsAssignment_1)*
2805 'import' 2805 { after(grammarAccess.getConfigurationScriptAccess().getCommandsAssignment_1()); }
2806 { after(grammarAccess.getViatraImportAccess().getImportKeyword_0()); } 2806)
2807) 2807;
2808; 2808finally {
2809finally { 2809 restoreStackSize(stackSize);
2810 restoreStackSize(stackSize); 2810}
2811} 2811
2812 2812
2813rule__ViatraImport__Group__1 2813rule__QualifiedName__Group__0
2814 @init { 2814 @init {
2815 int stackSize = keepStackSize(); 2815 int stackSize = keepStackSize();
2816 } 2816 }
2817: 2817:
2818 rule__ViatraImport__Group__1__Impl 2818 rule__QualifiedName__Group__0__Impl
2819 rule__ViatraImport__Group__2 2819 rule__QualifiedName__Group__1
2820; 2820;
2821finally { 2821finally {
2822 restoreStackSize(stackSize); 2822 restoreStackSize(stackSize);
2823} 2823}
2824 2824
2825rule__ViatraImport__Group__1__Impl 2825rule__QualifiedName__Group__0__Impl
2826 @init { 2826 @init {
2827 int stackSize = keepStackSize(); 2827 int stackSize = keepStackSize();
2828 } 2828 }
2829: 2829:
2830( 2830(
2831 { before(grammarAccess.getViatraImportAccess().getViatraKeyword_1()); } 2831 { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); }
2832 'viatra' 2832 RULE_ID
2833 { after(grammarAccess.getViatraImportAccess().getViatraKeyword_1()); } 2833 { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); }
2834) 2834)
2835; 2835;
2836finally { 2836finally {
2837 restoreStackSize(stackSize); 2837 restoreStackSize(stackSize);
2838} 2838}
2839 2839
2840rule__ViatraImport__Group__2 2840rule__QualifiedName__Group__1
2841 @init { 2841 @init {
2842 int stackSize = keepStackSize(); 2842 int stackSize = keepStackSize();
2843 } 2843 }
2844: 2844:
2845 rule__ViatraImport__Group__2__Impl 2845 rule__QualifiedName__Group__1__Impl
2846; 2846;
2847finally { 2847finally {
2848 restoreStackSize(stackSize); 2848 restoreStackSize(stackSize);
2849} 2849}
2850 2850
2851rule__ViatraImport__Group__2__Impl 2851rule__QualifiedName__Group__1__Impl
2852 @init { 2852 @init {
2853 int stackSize = keepStackSize(); 2853 int stackSize = keepStackSize();
2854 } 2854 }
2855: 2855:
2856( 2856(
2857 { before(grammarAccess.getViatraImportAccess().getImportedViatraAssignment_2()); } 2857 { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
2858 (rule__ViatraImport__ImportedViatraAssignment_2) 2858 (rule__QualifiedName__Group_1__0)*
2859 { after(grammarAccess.getViatraImportAccess().getImportedViatraAssignment_2()); } 2859 { after(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
2860) 2860)
2861; 2861;
2862finally { 2862finally {
2863 restoreStackSize(stackSize); 2863 restoreStackSize(stackSize);
2864} 2864}
2865 2865
2866 2866
2867rule__FileDeclaration__Group__0 2867rule__QualifiedName__Group_1__0
2868 @init { 2868 @init {
2869 int stackSize = keepStackSize(); 2869 int stackSize = keepStackSize();
2870 } 2870 }
2871: 2871:
2872 rule__FileDeclaration__Group__0__Impl 2872 rule__QualifiedName__Group_1__0__Impl
2873 rule__FileDeclaration__Group__1 2873 rule__QualifiedName__Group_1__1
2874; 2874;
2875finally { 2875finally {
2876 restoreStackSize(stackSize); 2876 restoreStackSize(stackSize);
2877} 2877}
2878 2878
2879rule__FileDeclaration__Group__0__Impl 2879rule__QualifiedName__Group_1__0__Impl
2880 @init { 2880 @init {
2881 int stackSize = keepStackSize(); 2881 int stackSize = keepStackSize();
2882 } 2882 }
2883: 2883:
2884( 2884(
2885 { before(grammarAccess.getFileDeclarationAccess().getFileKeyword_0()); } 2885 { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); }
2886 'file' 2886 '.'
2887 { after(grammarAccess.getFileDeclarationAccess().getFileKeyword_0()); } 2887 { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); }
2888) 2888)
2889; 2889;
2890finally { 2890finally {
2891 restoreStackSize(stackSize); 2891 restoreStackSize(stackSize);
2892} 2892}
2893 2893
2894rule__FileDeclaration__Group__1 2894rule__QualifiedName__Group_1__1
2895 @init { 2895 @init {
2896 int stackSize = keepStackSize(); 2896 int stackSize = keepStackSize();
2897 } 2897 }
2898: 2898:
2899 rule__FileDeclaration__Group__1__Impl 2899 rule__QualifiedName__Group_1__1__Impl
2900 rule__FileDeclaration__Group__2 2900;
2901; 2901finally {
2902finally { 2902 restoreStackSize(stackSize);
2903 restoreStackSize(stackSize); 2903}
2904} 2904
2905 2905rule__QualifiedName__Group_1__1__Impl
2906rule__FileDeclaration__Group__1__Impl 2906 @init {
2907 @init { 2907 int stackSize = keepStackSize();
2908 int stackSize = keepStackSize(); 2908 }
2909 } 2909:
2910: 2910(
2911( 2911 { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); }
2912 { before(grammarAccess.getFileDeclarationAccess().getNameAssignment_1()); } 2912 RULE_ID
2913 (rule__FileDeclaration__NameAssignment_1) 2913 { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); }
2914 { after(grammarAccess.getFileDeclarationAccess().getNameAssignment_1()); } 2914)
2915) 2915;
2916; 2916finally {
2917finally { 2917 restoreStackSize(stackSize);
2918 restoreStackSize(stackSize); 2918}
2919} 2919
2920 2920
2921rule__FileDeclaration__Group__2 2921rule__REALLiteral__Group__0
2922 @init { 2922 @init {
2923 int stackSize = keepStackSize(); 2923 int stackSize = keepStackSize();
2924 } 2924 }
2925: 2925:
2926 rule__FileDeclaration__Group__2__Impl 2926 rule__REALLiteral__Group__0__Impl
2927 rule__FileDeclaration__Group__3 2927 rule__REALLiteral__Group__1
2928; 2928;
2929finally { 2929finally {
2930 restoreStackSize(stackSize); 2930 restoreStackSize(stackSize);
2931} 2931}
2932 2932
2933rule__FileDeclaration__Group__2__Impl 2933rule__REALLiteral__Group__0__Impl
2934 @init { 2934 @init {
2935 int stackSize = keepStackSize(); 2935 int stackSize = keepStackSize();
2936 } 2936 }
2937: 2937:
2938( 2938(
2939 { before(grammarAccess.getFileDeclarationAccess().getEqualsSignKeyword_2()); } 2939 { before(grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); }
2940 '=' 2940 ('-')?
2941 { after(grammarAccess.getFileDeclarationAccess().getEqualsSignKeyword_2()); } 2941 { after(grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); }
2942) 2942)
2943; 2943;
2944finally { 2944finally {
2945 restoreStackSize(stackSize); 2945 restoreStackSize(stackSize);
2946} 2946}
2947 2947
2948rule__FileDeclaration__Group__3 2948rule__REALLiteral__Group__1
2949 @init { 2949 @init {
2950 int stackSize = keepStackSize(); 2950 int stackSize = keepStackSize();
2951 } 2951 }
2952: 2952:
2953 rule__FileDeclaration__Group__3__Impl 2953 rule__REALLiteral__Group__1__Impl
2954; 2954 rule__REALLiteral__Group__2
2955finally { 2955;
2956 restoreStackSize(stackSize); 2956finally {
2957} 2957 restoreStackSize(stackSize);
2958 2958}
2959rule__FileDeclaration__Group__3__Impl 2959
2960 @init { 2960rule__REALLiteral__Group__1__Impl
2961 int stackSize = keepStackSize(); 2961 @init {
2962 } 2962 int stackSize = keepStackSize();
2963: 2963 }
2964( 2964:
2965 { before(grammarAccess.getFileDeclarationAccess().getSpecificationAssignment_3()); } 2965(
2966 (rule__FileDeclaration__SpecificationAssignment_3) 2966 { before(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); }
2967 { after(grammarAccess.getFileDeclarationAccess().getSpecificationAssignment_3()); } 2967 RULE_INT
2968) 2968 { after(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); }
2969; 2969)
2970finally { 2970;
2971 restoreStackSize(stackSize); 2971finally {
2972} 2972 restoreStackSize(stackSize);
2973 2973}
2974 2974
2975rule__MetamodelSpecification__Group__0 2975rule__REALLiteral__Group__2
2976 @init { 2976 @init {
2977 int stackSize = keepStackSize(); 2977 int stackSize = keepStackSize();
2978 } 2978 }
2979: 2979:
2980 rule__MetamodelSpecification__Group__0__Impl 2980 rule__REALLiteral__Group__2__Impl
2981 rule__MetamodelSpecification__Group__1 2981 rule__REALLiteral__Group__3
2982; 2982;
2983finally { 2983finally {
2984 restoreStackSize(stackSize); 2984 restoreStackSize(stackSize);
2985} 2985}
2986 2986
2987rule__MetamodelSpecification__Group__0__Impl 2987rule__REALLiteral__Group__2__Impl
2988 @init { 2988 @init {
2989 int stackSize = keepStackSize(); 2989 int stackSize = keepStackSize();
2990 } 2990 }
2991: 2991:
2992( 2992(
2993 { before(grammarAccess.getMetamodelSpecificationAccess().getLeftCurlyBracketKeyword_0()); } 2993 { before(grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); }
2994 '{' 2994 '.'
2995 { after(grammarAccess.getMetamodelSpecificationAccess().getLeftCurlyBracketKeyword_0()); } 2995 { after(grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); }
2996) 2996)
2997; 2997;
2998finally { 2998finally {
2999 restoreStackSize(stackSize); 2999 restoreStackSize(stackSize);
3000} 3000}
3001 3001
3002rule__MetamodelSpecification__Group__1 3002rule__REALLiteral__Group__3
3003 @init { 3003 @init {
3004 int stackSize = keepStackSize(); 3004 int stackSize = keepStackSize();
3005 } 3005 }
3006: 3006:
3007 rule__MetamodelSpecification__Group__1__Impl 3007 rule__REALLiteral__Group__3__Impl
3008 rule__MetamodelSpecification__Group__2 3008;
3009; 3009finally {
3010finally { 3010 restoreStackSize(stackSize);
3011 restoreStackSize(stackSize); 3011}
3012} 3012
3013 3013rule__REALLiteral__Group__3__Impl
3014rule__MetamodelSpecification__Group__1__Impl 3014 @init {
3015 @init { 3015 int stackSize = keepStackSize();
3016 int stackSize = keepStackSize(); 3016 }
3017 } 3017:
3018: 3018(
3019( 3019 { before(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); }
3020 { before(grammarAccess.getMetamodelSpecificationAccess().getEntriesAssignment_1()); } 3020 RULE_INT
3021 (rule__MetamodelSpecification__EntriesAssignment_1) 3021 { after(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); }
3022 { after(grammarAccess.getMetamodelSpecificationAccess().getEntriesAssignment_1()); } 3022)
3023) 3023;
3024; 3024finally {
3025finally { 3025 restoreStackSize(stackSize);
3026 restoreStackSize(stackSize); 3026}
3027} 3027
3028 3028
3029rule__MetamodelSpecification__Group__2 3029rule__INTLiteral__Group__0
3030 @init { 3030 @init {
3031 int stackSize = keepStackSize(); 3031 int stackSize = keepStackSize();
3032 } 3032 }
3033: 3033:
3034 rule__MetamodelSpecification__Group__2__Impl 3034 rule__INTLiteral__Group__0__Impl
3035 rule__MetamodelSpecification__Group__3 3035 rule__INTLiteral__Group__1
3036; 3036;
3037finally { 3037finally {
3038 restoreStackSize(stackSize); 3038 restoreStackSize(stackSize);
3039} 3039}
3040 3040
3041rule__MetamodelSpecification__Group__2__Impl 3041rule__INTLiteral__Group__0__Impl
3042 @init { 3042 @init {
3043 int stackSize = keepStackSize(); 3043 int stackSize = keepStackSize();
3044 } 3044 }
3045: 3045:
3046( 3046(
3047 { before(grammarAccess.getMetamodelSpecificationAccess().getGroup_2()); } 3047 { before(grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); }
3048 (rule__MetamodelSpecification__Group_2__0)* 3048 ('-')?
3049 { after(grammarAccess.getMetamodelSpecificationAccess().getGroup_2()); } 3049 { after(grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); }
3050) 3050)
3051; 3051;
3052finally { 3052finally {
3053 restoreStackSize(stackSize); 3053 restoreStackSize(stackSize);
3054} 3054}
3055 3055
3056rule__MetamodelSpecification__Group__3 3056rule__INTLiteral__Group__1
3057 @init { 3057 @init {
3058 int stackSize = keepStackSize(); 3058 int stackSize = keepStackSize();
3059 } 3059 }
3060: 3060:
3061 rule__MetamodelSpecification__Group__3__Impl 3061 rule__INTLiteral__Group__1__Impl
3062; 3062;
3063finally { 3063finally {
3064 restoreStackSize(stackSize); 3064 restoreStackSize(stackSize);
3065} 3065}
3066 3066
3067rule__MetamodelSpecification__Group__3__Impl 3067rule__INTLiteral__Group__1__Impl
3068 @init { 3068 @init {
3069 int stackSize = keepStackSize(); 3069 int stackSize = keepStackSize();
3070 } 3070 }
3071: 3071:
3072( 3072(
3073 { before(grammarAccess.getMetamodelSpecificationAccess().getRightCurlyBracketKeyword_3()); } 3073 { before(grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); }
3074 '}' 3074 RULE_INT
3075 { after(grammarAccess.getMetamodelSpecificationAccess().getRightCurlyBracketKeyword_3()); } 3075 { after(grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); }
3076) 3076)
3077; 3077;
3078finally { 3078finally {
3079 restoreStackSize(stackSize); 3079 restoreStackSize(stackSize);
3080} 3080}
3081 3081
3082 3082
3083rule__MetamodelSpecification__Group_2__0 3083rule__EPackageImport__Group__0
3084 @init { 3084 @init {
3085 int stackSize = keepStackSize(); 3085 int stackSize = keepStackSize();
3086 } 3086 }
3087: 3087:
3088 rule__MetamodelSpecification__Group_2__0__Impl 3088 rule__EPackageImport__Group__0__Impl
3089 rule__MetamodelSpecification__Group_2__1 3089 rule__EPackageImport__Group__1
3090; 3090;
3091finally { 3091finally {
3092 restoreStackSize(stackSize); 3092 restoreStackSize(stackSize);
3093} 3093}
3094 3094
3095rule__MetamodelSpecification__Group_2__0__Impl 3095rule__EPackageImport__Group__0__Impl
3096 @init { 3096 @init {
3097 int stackSize = keepStackSize(); 3097 int stackSize = keepStackSize();
3098 } 3098 }
3099: 3099:
3100( 3100(
3101 { before(grammarAccess.getMetamodelSpecificationAccess().getCommaKeyword_2_0()); } 3101 { before(grammarAccess.getEPackageImportAccess().getImportKeyword_0()); }
3102 ',' 3102 'import'
3103 { after(grammarAccess.getMetamodelSpecificationAccess().getCommaKeyword_2_0()); } 3103 { after(grammarAccess.getEPackageImportAccess().getImportKeyword_0()); }
3104) 3104)
3105; 3105;
3106finally { 3106finally {
3107 restoreStackSize(stackSize); 3107 restoreStackSize(stackSize);
3108} 3108}
3109 3109
3110rule__MetamodelSpecification__Group_2__1 3110rule__EPackageImport__Group__1
3111 @init { 3111 @init {
3112 int stackSize = keepStackSize(); 3112 int stackSize = keepStackSize();
3113 } 3113 }
3114: 3114:
3115 rule__MetamodelSpecification__Group_2__1__Impl 3115 rule__EPackageImport__Group__1__Impl
3116; 3116 rule__EPackageImport__Group__2
3117finally { 3117;
3118 restoreStackSize(stackSize); 3118finally {
3119} 3119 restoreStackSize(stackSize);
3120 3120}
3121rule__MetamodelSpecification__Group_2__1__Impl 3121
3122 @init { 3122rule__EPackageImport__Group__1__Impl
3123 int stackSize = keepStackSize(); 3123 @init {
3124 } 3124 int stackSize = keepStackSize();
3125: 3125 }
3126( 3126:
3127 { before(grammarAccess.getMetamodelSpecificationAccess().getEntriesAssignment_2_1()); } 3127(
3128 (rule__MetamodelSpecification__EntriesAssignment_2_1) 3128 { before(grammarAccess.getEPackageImportAccess().getEpackageKeyword_1()); }
3129 { after(grammarAccess.getMetamodelSpecificationAccess().getEntriesAssignment_2_1()); } 3129 'epackage'
3130) 3130 { after(grammarAccess.getEPackageImportAccess().getEpackageKeyword_1()); }
3131; 3131)
3132finally { 3132;
3133 restoreStackSize(stackSize); 3133finally {
3134} 3134 restoreStackSize(stackSize);
3135 3135}
3136 3136
3137rule__AllPackageEntry__Group__0 3137rule__EPackageImport__Group__2
3138 @init { 3138 @init {
3139 int stackSize = keepStackSize(); 3139 int stackSize = keepStackSize();
3140 } 3140 }
3141: 3141:
3142 rule__AllPackageEntry__Group__0__Impl 3142 rule__EPackageImport__Group__2__Impl
3143 rule__AllPackageEntry__Group__1 3143;
3144; 3144finally {
3145finally { 3145 restoreStackSize(stackSize);
3146 restoreStackSize(stackSize); 3146}
3147} 3147
3148 3148rule__EPackageImport__Group__2__Impl
3149rule__AllPackageEntry__Group__0__Impl 3149 @init {
3150 @init { 3150 int stackSize = keepStackSize();
3151 int stackSize = keepStackSize(); 3151 }
3152 } 3152:
3153: 3153(
3154( 3154 { before(grammarAccess.getEPackageImportAccess().getImportedPackageAssignment_2()); }
3155 { before(grammarAccess.getAllPackageEntryAccess().getPackageKeyword_0()); } 3155 (rule__EPackageImport__ImportedPackageAssignment_2)
3156 'package' 3156 { after(grammarAccess.getEPackageImportAccess().getImportedPackageAssignment_2()); }
3157 { after(grammarAccess.getAllPackageEntryAccess().getPackageKeyword_0()); } 3157)
3158) 3158;
3159; 3159finally {
3160finally { 3160 restoreStackSize(stackSize);
3161 restoreStackSize(stackSize); 3161}
3162} 3162
3163 3163
3164rule__AllPackageEntry__Group__1 3164rule__ViatraImport__Group__0
3165 @init { 3165 @init {
3166 int stackSize = keepStackSize(); 3166 int stackSize = keepStackSize();
3167 } 3167 }
3168: 3168:
3169 rule__AllPackageEntry__Group__1__Impl 3169 rule__ViatraImport__Group__0__Impl
3170 rule__AllPackageEntry__Group__2 3170 rule__ViatraImport__Group__1
3171; 3171;
3172finally { 3172finally {
3173 restoreStackSize(stackSize); 3173 restoreStackSize(stackSize);
3174} 3174}
3175 3175
3176rule__AllPackageEntry__Group__1__Impl 3176rule__ViatraImport__Group__0__Impl
3177 @init { 3177 @init {
3178 int stackSize = keepStackSize(); 3178 int stackSize = keepStackSize();
3179 } 3179 }
3180: 3180:
3181( 3181(
3182 { before(grammarAccess.getAllPackageEntryAccess().getPackageAssignment_1()); } 3182 { before(grammarAccess.getViatraImportAccess().getImportKeyword_0()); }
3183 (rule__AllPackageEntry__PackageAssignment_1) 3183 'import'
3184 { after(grammarAccess.getAllPackageEntryAccess().getPackageAssignment_1()); } 3184 { after(grammarAccess.getViatraImportAccess().getImportKeyword_0()); }
3185) 3185)
3186; 3186;
3187finally { 3187finally {
3188 restoreStackSize(stackSize); 3188 restoreStackSize(stackSize);
3189} 3189}
3190 3190
3191rule__AllPackageEntry__Group__2 3191rule__ViatraImport__Group__1
3192 @init { 3192 @init {
3193 int stackSize = keepStackSize(); 3193 int stackSize = keepStackSize();
3194 } 3194 }
3195: 3195:
3196 rule__AllPackageEntry__Group__2__Impl 3196 rule__ViatraImport__Group__1__Impl
3197; 3197 rule__ViatraImport__Group__2
3198finally { 3198;
3199 restoreStackSize(stackSize); 3199finally {
3200} 3200 restoreStackSize(stackSize);
3201 3201}
3202rule__AllPackageEntry__Group__2__Impl 3202
3203 @init { 3203rule__ViatraImport__Group__1__Impl
3204 int stackSize = keepStackSize(); 3204 @init {
3205 } 3205 int stackSize = keepStackSize();
3206: 3206 }
3207( 3207:
3208 { before(grammarAccess.getAllPackageEntryAccess().getGroup_2()); } 3208(
3209 (rule__AllPackageEntry__Group_2__0)? 3209 { before(grammarAccess.getViatraImportAccess().getViatraKeyword_1()); }
3210 { after(grammarAccess.getAllPackageEntryAccess().getGroup_2()); } 3210 'viatra'
3211) 3211 { after(grammarAccess.getViatraImportAccess().getViatraKeyword_1()); }
3212; 3212)
3213finally { 3213;
3214 restoreStackSize(stackSize); 3214finally {
3215} 3215 restoreStackSize(stackSize);
3216 3216}
3217 3217
3218rule__AllPackageEntry__Group_2__0 3218rule__ViatraImport__Group__2
3219 @init { 3219 @init {
3220 int stackSize = keepStackSize(); 3220 int stackSize = keepStackSize();
3221 } 3221 }
3222: 3222:
3223 rule__AllPackageEntry__Group_2__0__Impl 3223 rule__ViatraImport__Group__2__Impl
3224 rule__AllPackageEntry__Group_2__1 3224;
3225; 3225finally {
3226finally { 3226 restoreStackSize(stackSize);
3227 restoreStackSize(stackSize); 3227}
3228} 3228
3229 3229rule__ViatraImport__Group__2__Impl
3230rule__AllPackageEntry__Group_2__0__Impl 3230 @init {
3231 @init { 3231 int stackSize = keepStackSize();
3232 int stackSize = keepStackSize(); 3232 }
3233 } 3233:
3234: 3234(
3235( 3235 { before(grammarAccess.getViatraImportAccess().getImportedViatraAssignment_2()); }
3236 { before(grammarAccess.getAllPackageEntryAccess().getExcludingKeyword_2_0()); } 3236 (rule__ViatraImport__ImportedViatraAssignment_2)
3237 'excluding' 3237 { after(grammarAccess.getViatraImportAccess().getImportedViatraAssignment_2()); }
3238 { after(grammarAccess.getAllPackageEntryAccess().getExcludingKeyword_2_0()); } 3238)
3239) 3239;
3240; 3240finally {
3241finally { 3241 restoreStackSize(stackSize);
3242 restoreStackSize(stackSize); 3242}
3243} 3243
3244 3244
3245rule__AllPackageEntry__Group_2__1 3245rule__CftImport__Group__0
3246 @init { 3246 @init {
3247 int stackSize = keepStackSize(); 3247 int stackSize = keepStackSize();
3248 } 3248 }
3249: 3249:
3250 rule__AllPackageEntry__Group_2__1__Impl 3250 rule__CftImport__Group__0__Impl
3251 rule__AllPackageEntry__Group_2__2 3251 rule__CftImport__Group__1
3252; 3252;
3253finally { 3253finally {
3254 restoreStackSize(stackSize); 3254 restoreStackSize(stackSize);
3255} 3255}
3256 3256
3257rule__AllPackageEntry__Group_2__1__Impl 3257rule__CftImport__Group__0__Impl
3258 @init { 3258 @init {
3259 int stackSize = keepStackSize(); 3259 int stackSize = keepStackSize();
3260 } 3260 }
3261: 3261:
3262( 3262(
3263 { before(grammarAccess.getAllPackageEntryAccess().getLeftCurlyBracketKeyword_2_1()); } 3263 { before(grammarAccess.getCftImportAccess().getImportKeyword_0()); }
3264 '{' 3264 'import'
3265 { after(grammarAccess.getAllPackageEntryAccess().getLeftCurlyBracketKeyword_2_1()); } 3265 { after(grammarAccess.getCftImportAccess().getImportKeyword_0()); }
3266) 3266)
3267; 3267;
3268finally { 3268finally {
3269 restoreStackSize(stackSize); 3269 restoreStackSize(stackSize);
3270} 3270}
3271 3271
3272rule__AllPackageEntry__Group_2__2 3272rule__CftImport__Group__1
3273 @init { 3273 @init {
3274 int stackSize = keepStackSize(); 3274 int stackSize = keepStackSize();
3275 } 3275 }
3276: 3276:
3277 rule__AllPackageEntry__Group_2__2__Impl 3277 rule__CftImport__Group__1__Impl
3278 rule__AllPackageEntry__Group_2__3 3278 rule__CftImport__Group__2
3279; 3279;
3280finally { 3280finally {
3281 restoreStackSize(stackSize); 3281 restoreStackSize(stackSize);
3282} 3282}
3283 3283
3284rule__AllPackageEntry__Group_2__2__Impl 3284rule__CftImport__Group__1__Impl
3285 @init { 3285 @init {
3286 int stackSize = keepStackSize(); 3286 int stackSize = keepStackSize();
3287 } 3287 }
3288: 3288:
3289( 3289(
3290 { before(grammarAccess.getAllPackageEntryAccess().getExclusionAssignment_2_2()); } 3290 { before(grammarAccess.getCftImportAccess().getReliabilityKeyword_1()); }
3291 (rule__AllPackageEntry__ExclusionAssignment_2_2) 3291 'reliability'
3292 { after(grammarAccess.getAllPackageEntryAccess().getExclusionAssignment_2_2()); } 3292 { after(grammarAccess.getCftImportAccess().getReliabilityKeyword_1()); }
3293) 3293)
3294; 3294;
3295finally { 3295finally {
3296 restoreStackSize(stackSize); 3296 restoreStackSize(stackSize);
3297} 3297}
3298 3298
3299rule__AllPackageEntry__Group_2__3 3299rule__CftImport__Group__2
3300 @init { 3300 @init {
3301 int stackSize = keepStackSize(); 3301 int stackSize = keepStackSize();
3302 } 3302 }
3303: 3303:
3304 rule__AllPackageEntry__Group_2__3__Impl 3304 rule__CftImport__Group__2__Impl
3305 rule__AllPackageEntry__Group_2__4 3305;
3306; 3306finally {
3307finally { 3307 restoreStackSize(stackSize);
3308 restoreStackSize(stackSize); 3308}
3309} 3309
3310 3310rule__CftImport__Group__2__Impl
3311rule__AllPackageEntry__Group_2__3__Impl 3311 @init {
3312 @init { 3312 int stackSize = keepStackSize();
3313 int stackSize = keepStackSize(); 3313 }
3314 } 3314:
3315: 3315(
3316( 3316 { before(grammarAccess.getCftImportAccess().getImportedCftAssignment_2()); }
3317 { before(grammarAccess.getAllPackageEntryAccess().getGroup_2_3()); } 3317 (rule__CftImport__ImportedCftAssignment_2)
3318 (rule__AllPackageEntry__Group_2_3__0)* 3318 { after(grammarAccess.getCftImportAccess().getImportedCftAssignment_2()); }
3319 { after(grammarAccess.getAllPackageEntryAccess().getGroup_2_3()); } 3319)
3320) 3320;
3321; 3321finally {
3322finally { 3322 restoreStackSize(stackSize);
3323 restoreStackSize(stackSize); 3323}
3324} 3324
3325 3325
3326rule__AllPackageEntry__Group_2__4 3326rule__FileDeclaration__Group__0
3327 @init { 3327 @init {
3328 int stackSize = keepStackSize(); 3328 int stackSize = keepStackSize();
3329 } 3329 }
3330: 3330:
3331 rule__AllPackageEntry__Group_2__4__Impl 3331 rule__FileDeclaration__Group__0__Impl
3332; 3332 rule__FileDeclaration__Group__1
3333finally { 3333;
3334 restoreStackSize(stackSize); 3334finally {
3335} 3335 restoreStackSize(stackSize);
3336 3336}
3337rule__AllPackageEntry__Group_2__4__Impl 3337
3338 @init { 3338rule__FileDeclaration__Group__0__Impl
3339 int stackSize = keepStackSize(); 3339 @init {
3340 } 3340 int stackSize = keepStackSize();
3341: 3341 }
3342( 3342:
3343 { before(grammarAccess.getAllPackageEntryAccess().getRightCurlyBracketKeyword_2_4()); } 3343(
3344 '}' 3344 { before(grammarAccess.getFileDeclarationAccess().getFileKeyword_0()); }
3345 { after(grammarAccess.getAllPackageEntryAccess().getRightCurlyBracketKeyword_2_4()); } 3345 'file'
3346) 3346 { after(grammarAccess.getFileDeclarationAccess().getFileKeyword_0()); }
3347; 3347)
3348finally { 3348;
3349 restoreStackSize(stackSize); 3349finally {
3350} 3350 restoreStackSize(stackSize);
3351 3351}
3352 3352
3353rule__AllPackageEntry__Group_2_3__0 3353rule__FileDeclaration__Group__1
3354 @init { 3354 @init {
3355 int stackSize = keepStackSize(); 3355 int stackSize = keepStackSize();
3356 } 3356 }
3357: 3357:
3358 rule__AllPackageEntry__Group_2_3__0__Impl 3358 rule__FileDeclaration__Group__1__Impl
3359 rule__AllPackageEntry__Group_2_3__1 3359 rule__FileDeclaration__Group__2
3360; 3360;
3361finally { 3361finally {
3362 restoreStackSize(stackSize); 3362 restoreStackSize(stackSize);
3363} 3363}
3364 3364
3365rule__AllPackageEntry__Group_2_3__0__Impl 3365rule__FileDeclaration__Group__1__Impl
3366 @init { 3366 @init {
3367 int stackSize = keepStackSize(); 3367 int stackSize = keepStackSize();
3368 } 3368 }
3369: 3369:
3370( 3370(
3371 { before(grammarAccess.getAllPackageEntryAccess().getCommaKeyword_2_3_0()); } 3371 { before(grammarAccess.getFileDeclarationAccess().getNameAssignment_1()); }
3372 ',' 3372 (rule__FileDeclaration__NameAssignment_1)
3373 { after(grammarAccess.getAllPackageEntryAccess().getCommaKeyword_2_3_0()); } 3373 { after(grammarAccess.getFileDeclarationAccess().getNameAssignment_1()); }
3374) 3374)
3375; 3375;
3376finally { 3376finally {
3377 restoreStackSize(stackSize); 3377 restoreStackSize(stackSize);
3378} 3378}
3379 3379
3380rule__AllPackageEntry__Group_2_3__1 3380rule__FileDeclaration__Group__2
3381 @init { 3381 @init {
3382 int stackSize = keepStackSize(); 3382 int stackSize = keepStackSize();
3383 } 3383 }
3384: 3384:
3385 rule__AllPackageEntry__Group_2_3__1__Impl 3385 rule__FileDeclaration__Group__2__Impl
3386; 3386 rule__FileDeclaration__Group__3
3387finally { 3387;
3388 restoreStackSize(stackSize); 3388finally {
3389} 3389 restoreStackSize(stackSize);
3390 3390}
3391rule__AllPackageEntry__Group_2_3__1__Impl 3391
3392 @init { 3392rule__FileDeclaration__Group__2__Impl
3393 int stackSize = keepStackSize(); 3393 @init {
3394 } 3394 int stackSize = keepStackSize();
3395: 3395 }
3396( 3396:
3397 { before(grammarAccess.getAllPackageEntryAccess().getExclusionAssignment_2_3_1()); } 3397(
3398 (rule__AllPackageEntry__ExclusionAssignment_2_3_1) 3398 { before(grammarAccess.getFileDeclarationAccess().getEqualsSignKeyword_2()); }
3399 { after(grammarAccess.getAllPackageEntryAccess().getExclusionAssignment_2_3_1()); } 3399 '='
3400) 3400 { after(grammarAccess.getFileDeclarationAccess().getEqualsSignKeyword_2()); }
3401; 3401)
3402finally { 3402;
3403 restoreStackSize(stackSize); 3403finally {
3404} 3404 restoreStackSize(stackSize);
3405 3405}
3406 3406
3407rule__MetamodelElement__Group__0 3407rule__FileDeclaration__Group__3
3408 @init { 3408 @init {
3409 int stackSize = keepStackSize(); 3409 int stackSize = keepStackSize();
3410 } 3410 }
3411: 3411:
3412 rule__MetamodelElement__Group__0__Impl 3412 rule__FileDeclaration__Group__3__Impl
3413 rule__MetamodelElement__Group__1 3413;
3414; 3414finally {
3415finally { 3415 restoreStackSize(stackSize);
3416 restoreStackSize(stackSize); 3416}
3417} 3417
3418 3418rule__FileDeclaration__Group__3__Impl
3419rule__MetamodelElement__Group__0__Impl 3419 @init {
3420 @init { 3420 int stackSize = keepStackSize();
3421 int stackSize = keepStackSize(); 3421 }
3422 } 3422:
3423: 3423(
3424( 3424 { before(grammarAccess.getFileDeclarationAccess().getSpecificationAssignment_3()); }
3425 { before(grammarAccess.getMetamodelElementAccess().getGroup_0()); } 3425 (rule__FileDeclaration__SpecificationAssignment_3)
3426 (rule__MetamodelElement__Group_0__0)? 3426 { after(grammarAccess.getFileDeclarationAccess().getSpecificationAssignment_3()); }
3427 { after(grammarAccess.getMetamodelElementAccess().getGroup_0()); } 3427)
3428) 3428;
3429; 3429finally {
3430finally { 3430 restoreStackSize(stackSize);
3431 restoreStackSize(stackSize); 3431}
3432} 3432
3433 3433
3434rule__MetamodelElement__Group__1 3434rule__MetamodelSpecification__Group__0
3435 @init { 3435 @init {
3436 int stackSize = keepStackSize(); 3436 int stackSize = keepStackSize();
3437 } 3437 }
3438: 3438:
3439 rule__MetamodelElement__Group__1__Impl 3439 rule__MetamodelSpecification__Group__0__Impl
3440 rule__MetamodelElement__Group__2 3440 rule__MetamodelSpecification__Group__1
3441; 3441;
3442finally { 3442finally {
3443 restoreStackSize(stackSize); 3443 restoreStackSize(stackSize);
3444} 3444}
3445 3445
3446rule__MetamodelElement__Group__1__Impl 3446rule__MetamodelSpecification__Group__0__Impl
3447 @init { 3447 @init {
3448 int stackSize = keepStackSize(); 3448 int stackSize = keepStackSize();
3449 } 3449 }
3450: 3450:
3451( 3451(
3452 { before(grammarAccess.getMetamodelElementAccess().getClassifierAssignment_1()); } 3452 { before(grammarAccess.getMetamodelSpecificationAccess().getLeftCurlyBracketKeyword_0()); }
3453 (rule__MetamodelElement__ClassifierAssignment_1) 3453 '{'
3454 { after(grammarAccess.getMetamodelElementAccess().getClassifierAssignment_1()); } 3454 { after(grammarAccess.getMetamodelSpecificationAccess().getLeftCurlyBracketKeyword_0()); }
3455) 3455)
3456; 3456;
3457finally { 3457finally {
3458 restoreStackSize(stackSize); 3458 restoreStackSize(stackSize);
3459} 3459}
3460 3460
3461rule__MetamodelElement__Group__2 3461rule__MetamodelSpecification__Group__1
3462 @init { 3462 @init {
3463 int stackSize = keepStackSize(); 3463 int stackSize = keepStackSize();
3464 } 3464 }
3465: 3465:
3466 rule__MetamodelElement__Group__2__Impl 3466 rule__MetamodelSpecification__Group__1__Impl
3467; 3467 rule__MetamodelSpecification__Group__2
3468finally { 3468;
3469 restoreStackSize(stackSize); 3469finally {
3470} 3470 restoreStackSize(stackSize);
3471 3471}
3472rule__MetamodelElement__Group__2__Impl 3472
3473 @init { 3473rule__MetamodelSpecification__Group__1__Impl
3474 int stackSize = keepStackSize(); 3474 @init {
3475 } 3475 int stackSize = keepStackSize();
3476: 3476 }
3477( 3477:
3478 { before(grammarAccess.getMetamodelElementAccess().getGroup_2()); } 3478(
3479 (rule__MetamodelElement__Group_2__0)? 3479 { before(grammarAccess.getMetamodelSpecificationAccess().getEntriesAssignment_1()); }
3480 { after(grammarAccess.getMetamodelElementAccess().getGroup_2()); } 3480 (rule__MetamodelSpecification__EntriesAssignment_1)
3481) 3481 { after(grammarAccess.getMetamodelSpecificationAccess().getEntriesAssignment_1()); }
3482; 3482)
3483finally { 3483;
3484 restoreStackSize(stackSize); 3484finally {
3485} 3485 restoreStackSize(stackSize);
3486 3486}
3487 3487
3488rule__MetamodelElement__Group_0__0 3488rule__MetamodelSpecification__Group__2
3489 @init { 3489 @init {
3490 int stackSize = keepStackSize(); 3490 int stackSize = keepStackSize();
3491 } 3491 }
3492: 3492:
3493 rule__MetamodelElement__Group_0__0__Impl 3493 rule__MetamodelSpecification__Group__2__Impl
3494 rule__MetamodelElement__Group_0__1 3494 rule__MetamodelSpecification__Group__3
3495; 3495;
3496finally { 3496finally {
3497 restoreStackSize(stackSize); 3497 restoreStackSize(stackSize);
3498} 3498}
3499 3499
3500rule__MetamodelElement__Group_0__0__Impl 3500rule__MetamodelSpecification__Group__2__Impl
3501 @init { 3501 @init {
3502 int stackSize = keepStackSize(); 3502 int stackSize = keepStackSize();
3503 } 3503 }
3504: 3504:
3505( 3505(
3506 { before(grammarAccess.getMetamodelElementAccess().getPackageAssignment_0_0()); } 3506 { before(grammarAccess.getMetamodelSpecificationAccess().getGroup_2()); }
3507 (rule__MetamodelElement__PackageAssignment_0_0) 3507 (rule__MetamodelSpecification__Group_2__0)*
3508 { after(grammarAccess.getMetamodelElementAccess().getPackageAssignment_0_0()); } 3508 { after(grammarAccess.getMetamodelSpecificationAccess().getGroup_2()); }
3509) 3509)
3510; 3510;
3511finally { 3511finally {
3512 restoreStackSize(stackSize); 3512 restoreStackSize(stackSize);
3513} 3513}
3514 3514
3515rule__MetamodelElement__Group_0__1 3515rule__MetamodelSpecification__Group__3
3516 @init { 3516 @init {
3517 int stackSize = keepStackSize(); 3517 int stackSize = keepStackSize();
3518 } 3518 }
3519: 3519:
3520 rule__MetamodelElement__Group_0__1__Impl 3520 rule__MetamodelSpecification__Group__3__Impl
3521; 3521;
3522finally { 3522finally {
3523 restoreStackSize(stackSize); 3523 restoreStackSize(stackSize);
3524} 3524}
3525 3525
3526rule__MetamodelElement__Group_0__1__Impl 3526rule__MetamodelSpecification__Group__3__Impl
3527 @init { 3527 @init {
3528 int stackSize = keepStackSize(); 3528 int stackSize = keepStackSize();
3529 } 3529 }
3530: 3530:
3531( 3531(
3532 { before(grammarAccess.getMetamodelElementAccess().getColonColonKeyword_0_1()); } 3532 { before(grammarAccess.getMetamodelSpecificationAccess().getRightCurlyBracketKeyword_3()); }
3533 '::' 3533 '}'
3534 { after(grammarAccess.getMetamodelElementAccess().getColonColonKeyword_0_1()); } 3534 { after(grammarAccess.getMetamodelSpecificationAccess().getRightCurlyBracketKeyword_3()); }
3535) 3535)
3536; 3536;
3537finally { 3537finally {
3538 restoreStackSize(stackSize); 3538 restoreStackSize(stackSize);
3539} 3539}
3540 3540
3541 3541
3542rule__MetamodelElement__Group_2__0 3542rule__MetamodelSpecification__Group_2__0
3543 @init { 3543 @init {
3544 int stackSize = keepStackSize(); 3544 int stackSize = keepStackSize();
3545 } 3545 }
3546: 3546:
3547 rule__MetamodelElement__Group_2__0__Impl 3547 rule__MetamodelSpecification__Group_2__0__Impl
3548 rule__MetamodelElement__Group_2__1 3548 rule__MetamodelSpecification__Group_2__1
3549; 3549;
3550finally { 3550finally {
3551 restoreStackSize(stackSize); 3551 restoreStackSize(stackSize);
3552} 3552}
3553 3553
3554rule__MetamodelElement__Group_2__0__Impl 3554rule__MetamodelSpecification__Group_2__0__Impl
3555 @init { 3555 @init {
3556 int stackSize = keepStackSize(); 3556 int stackSize = keepStackSize();
3557 } 3557 }
3558: 3558:
3559( 3559(
3560 { before(grammarAccess.getMetamodelElementAccess().getFullStopKeyword_2_0()); } 3560 { before(grammarAccess.getMetamodelSpecificationAccess().getCommaKeyword_2_0()); }
3561 '.' 3561 ','
3562 { after(grammarAccess.getMetamodelElementAccess().getFullStopKeyword_2_0()); } 3562 { after(grammarAccess.getMetamodelSpecificationAccess().getCommaKeyword_2_0()); }
3563) 3563)
3564; 3564;
3565finally { 3565finally {
3566 restoreStackSize(stackSize); 3566 restoreStackSize(stackSize);
3567} 3567}
3568 3568
3569rule__MetamodelElement__Group_2__1 3569rule__MetamodelSpecification__Group_2__1
3570 @init { 3570 @init {
3571 int stackSize = keepStackSize(); 3571 int stackSize = keepStackSize();
3572 } 3572 }
3573: 3573:
3574 rule__MetamodelElement__Group_2__1__Impl 3574 rule__MetamodelSpecification__Group_2__1__Impl
3575; 3575;
3576finally { 3576finally {
3577 restoreStackSize(stackSize); 3577 restoreStackSize(stackSize);
3578} 3578}
3579 3579
3580rule__MetamodelElement__Group_2__1__Impl 3580rule__MetamodelSpecification__Group_2__1__Impl
3581 @init { 3581 @init {
3582 int stackSize = keepStackSize(); 3582 int stackSize = keepStackSize();
3583 } 3583 }
3584: 3584:
3585( 3585(
3586 { before(grammarAccess.getMetamodelElementAccess().getFeatureAssignment_2_1()); } 3586 { before(grammarAccess.getMetamodelSpecificationAccess().getEntriesAssignment_2_1()); }
3587 (rule__MetamodelElement__FeatureAssignment_2_1) 3587 (rule__MetamodelSpecification__EntriesAssignment_2_1)
3588 { after(grammarAccess.getMetamodelElementAccess().getFeatureAssignment_2_1()); } 3588 { after(grammarAccess.getMetamodelSpecificationAccess().getEntriesAssignment_2_1()); }
3589) 3589)
3590; 3590;
3591finally { 3591finally {
3592 restoreStackSize(stackSize); 3592 restoreStackSize(stackSize);
3593} 3593}
3594 3594
3595 3595
3596rule__MetamodelDeclaration__Group__0 3596rule__AllPackageEntry__Group__0
3597 @init { 3597 @init {
3598 int stackSize = keepStackSize(); 3598 int stackSize = keepStackSize();
3599 } 3599 }
3600: 3600:
3601 rule__MetamodelDeclaration__Group__0__Impl 3601 rule__AllPackageEntry__Group__0__Impl
3602 rule__MetamodelDeclaration__Group__1 3602 rule__AllPackageEntry__Group__1
3603; 3603;
3604finally { 3604finally {
3605 restoreStackSize(stackSize); 3605 restoreStackSize(stackSize);
3606} 3606}
3607 3607
3608rule__MetamodelDeclaration__Group__0__Impl 3608rule__AllPackageEntry__Group__0__Impl
3609 @init { 3609 @init {
3610 int stackSize = keepStackSize(); 3610 int stackSize = keepStackSize();
3611 } 3611 }
3612: 3612:
3613( 3613(
3614 { before(grammarAccess.getMetamodelDeclarationAccess().getMetamodelKeyword_0()); } 3614 { before(grammarAccess.getAllPackageEntryAccess().getPackageKeyword_0()); }
3615 'metamodel' 3615 'package'
3616 { after(grammarAccess.getMetamodelDeclarationAccess().getMetamodelKeyword_0()); } 3616 { after(grammarAccess.getAllPackageEntryAccess().getPackageKeyword_0()); }
3617) 3617)
3618; 3618;
3619finally { 3619finally {
3620 restoreStackSize(stackSize); 3620 restoreStackSize(stackSize);
3621} 3621}
3622 3622
3623rule__MetamodelDeclaration__Group__1 3623rule__AllPackageEntry__Group__1
3624 @init { 3624 @init {
3625 int stackSize = keepStackSize(); 3625 int stackSize = keepStackSize();
3626 } 3626 }
3627: 3627:
3628 rule__MetamodelDeclaration__Group__1__Impl 3628 rule__AllPackageEntry__Group__1__Impl
3629 rule__MetamodelDeclaration__Group__2 3629 rule__AllPackageEntry__Group__2
3630; 3630;
3631finally { 3631finally {
3632 restoreStackSize(stackSize); 3632 restoreStackSize(stackSize);
3633} 3633}
3634 3634
3635rule__MetamodelDeclaration__Group__1__Impl 3635rule__AllPackageEntry__Group__1__Impl
3636 @init { 3636 @init {
3637 int stackSize = keepStackSize(); 3637 int stackSize = keepStackSize();
3638 } 3638 }
3639: 3639:
3640( 3640(
3641 { before(grammarAccess.getMetamodelDeclarationAccess().getNameAssignment_1()); } 3641 { before(grammarAccess.getAllPackageEntryAccess().getPackageAssignment_1()); }
3642 (rule__MetamodelDeclaration__NameAssignment_1) 3642 (rule__AllPackageEntry__PackageAssignment_1)
3643 { after(grammarAccess.getMetamodelDeclarationAccess().getNameAssignment_1()); } 3643 { after(grammarAccess.getAllPackageEntryAccess().getPackageAssignment_1()); }
3644) 3644)
3645; 3645;
3646finally { 3646finally {
3647 restoreStackSize(stackSize); 3647 restoreStackSize(stackSize);
3648} 3648}
3649 3649
3650rule__MetamodelDeclaration__Group__2 3650rule__AllPackageEntry__Group__2
3651 @init { 3651 @init {
3652 int stackSize = keepStackSize(); 3652 int stackSize = keepStackSize();
3653 } 3653 }
3654: 3654:
3655 rule__MetamodelDeclaration__Group__2__Impl 3655 rule__AllPackageEntry__Group__2__Impl
3656; 3656;
3657finally { 3657finally {
3658 restoreStackSize(stackSize); 3658 restoreStackSize(stackSize);
3659} 3659}
3660 3660
3661rule__MetamodelDeclaration__Group__2__Impl 3661rule__AllPackageEntry__Group__2__Impl
3662 @init { 3662 @init {
3663 int stackSize = keepStackSize(); 3663 int stackSize = keepStackSize();
3664 } 3664 }
3665: 3665:
3666( 3666(
3667 { before(grammarAccess.getMetamodelDeclarationAccess().getSpecificationAssignment_2()); } 3667 { before(grammarAccess.getAllPackageEntryAccess().getGroup_2()); }
3668 (rule__MetamodelDeclaration__SpecificationAssignment_2) 3668 (rule__AllPackageEntry__Group_2__0)?
3669 { after(grammarAccess.getMetamodelDeclarationAccess().getSpecificationAssignment_2()); } 3669 { after(grammarAccess.getAllPackageEntryAccess().getGroup_2()); }
3670) 3670)
3671; 3671;
3672finally { 3672finally {
3673 restoreStackSize(stackSize); 3673 restoreStackSize(stackSize);
3674} 3674}
3675 3675
3676 3676
3677rule__PartialModelSpecification__Group__0 3677rule__AllPackageEntry__Group_2__0
3678 @init { 3678 @init {
3679 int stackSize = keepStackSize(); 3679 int stackSize = keepStackSize();
3680 } 3680 }
3681: 3681:
3682 rule__PartialModelSpecification__Group__0__Impl 3682 rule__AllPackageEntry__Group_2__0__Impl
3683 rule__PartialModelSpecification__Group__1 3683 rule__AllPackageEntry__Group_2__1
3684; 3684;
3685finally { 3685finally {
3686 restoreStackSize(stackSize); 3686 restoreStackSize(stackSize);
3687} 3687}
3688 3688
3689rule__PartialModelSpecification__Group__0__Impl 3689rule__AllPackageEntry__Group_2__0__Impl
3690 @init { 3690 @init {
3691 int stackSize = keepStackSize(); 3691 int stackSize = keepStackSize();
3692 } 3692 }
3693: 3693:
3694( 3694(
3695 { before(grammarAccess.getPartialModelSpecificationAccess().getLeftCurlyBracketKeyword_0()); } 3695 { before(grammarAccess.getAllPackageEntryAccess().getExcludingKeyword_2_0()); }
3696 '{' 3696 'excluding'
3697 { after(grammarAccess.getPartialModelSpecificationAccess().getLeftCurlyBracketKeyword_0()); } 3697 { after(grammarAccess.getAllPackageEntryAccess().getExcludingKeyword_2_0()); }
3698) 3698)
3699; 3699;
3700finally { 3700finally {
3701 restoreStackSize(stackSize); 3701 restoreStackSize(stackSize);
3702} 3702}
3703 3703
3704rule__PartialModelSpecification__Group__1 3704rule__AllPackageEntry__Group_2__1
3705 @init { 3705 @init {
3706 int stackSize = keepStackSize(); 3706 int stackSize = keepStackSize();
3707 } 3707 }
3708: 3708:
3709 rule__PartialModelSpecification__Group__1__Impl 3709 rule__AllPackageEntry__Group_2__1__Impl
3710 rule__PartialModelSpecification__Group__2 3710 rule__AllPackageEntry__Group_2__2
3711; 3711;
3712finally { 3712finally {
3713 restoreStackSize(stackSize); 3713 restoreStackSize(stackSize);
3714} 3714}
3715 3715
3716rule__PartialModelSpecification__Group__1__Impl 3716rule__AllPackageEntry__Group_2__1__Impl
3717 @init { 3717 @init {
3718 int stackSize = keepStackSize(); 3718 int stackSize = keepStackSize();
3719 } 3719 }
3720: 3720:
3721( 3721(
3722 { before(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_1()); } 3722 { before(grammarAccess.getAllPackageEntryAccess().getLeftCurlyBracketKeyword_2_1()); }
3723 (rule__PartialModelSpecification__EntryAssignment_1) 3723 '{'
3724 { after(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_1()); } 3724 { after(grammarAccess.getAllPackageEntryAccess().getLeftCurlyBracketKeyword_2_1()); }
3725) 3725)
3726; 3726;
3727finally { 3727finally {
3728 restoreStackSize(stackSize); 3728 restoreStackSize(stackSize);
3729} 3729}
3730 3730
3731rule__PartialModelSpecification__Group__2 3731rule__AllPackageEntry__Group_2__2
3732 @init { 3732 @init {
3733 int stackSize = keepStackSize(); 3733 int stackSize = keepStackSize();
3734 } 3734 }
3735: 3735:
3736 rule__PartialModelSpecification__Group__2__Impl 3736 rule__AllPackageEntry__Group_2__2__Impl
3737 rule__PartialModelSpecification__Group__3 3737 rule__AllPackageEntry__Group_2__3
3738; 3738;
3739finally { 3739finally {
3740 restoreStackSize(stackSize); 3740 restoreStackSize(stackSize);
3741} 3741}
3742 3742
3743rule__PartialModelSpecification__Group__2__Impl 3743rule__AllPackageEntry__Group_2__2__Impl
3744 @init { 3744 @init {
3745 int stackSize = keepStackSize(); 3745 int stackSize = keepStackSize();
3746 } 3746 }
3747: 3747:
3748( 3748(
3749 { before(grammarAccess.getPartialModelSpecificationAccess().getGroup_2()); } 3749 { before(grammarAccess.getAllPackageEntryAccess().getExclusionAssignment_2_2()); }
3750 (rule__PartialModelSpecification__Group_2__0)? 3750 (rule__AllPackageEntry__ExclusionAssignment_2_2)
3751 { after(grammarAccess.getPartialModelSpecificationAccess().getGroup_2()); } 3751 { after(grammarAccess.getAllPackageEntryAccess().getExclusionAssignment_2_2()); }
3752) 3752)
3753; 3753;
3754finally { 3754finally {
3755 restoreStackSize(stackSize); 3755 restoreStackSize(stackSize);
3756} 3756}
3757 3757
3758rule__PartialModelSpecification__Group__3 3758rule__AllPackageEntry__Group_2__3
3759 @init { 3759 @init {
3760 int stackSize = keepStackSize(); 3760 int stackSize = keepStackSize();
3761 } 3761 }
3762: 3762:
3763 rule__PartialModelSpecification__Group__3__Impl 3763 rule__AllPackageEntry__Group_2__3__Impl
3764; 3764 rule__AllPackageEntry__Group_2__4
3765finally { 3765;
3766 restoreStackSize(stackSize); 3766finally {
3767} 3767 restoreStackSize(stackSize);
3768 3768}
3769rule__PartialModelSpecification__Group__3__Impl 3769
3770 @init { 3770rule__AllPackageEntry__Group_2__3__Impl
3771 int stackSize = keepStackSize(); 3771 @init {
3772 } 3772 int stackSize = keepStackSize();
3773: 3773 }
3774( 3774:
3775 { before(grammarAccess.getPartialModelSpecificationAccess().getRightCurlyBracketKeyword_3()); } 3775(
3776 '}' 3776 { before(grammarAccess.getAllPackageEntryAccess().getGroup_2_3()); }
3777 { after(grammarAccess.getPartialModelSpecificationAccess().getRightCurlyBracketKeyword_3()); } 3777 (rule__AllPackageEntry__Group_2_3__0)*
3778) 3778 { after(grammarAccess.getAllPackageEntryAccess().getGroup_2_3()); }
3779; 3779)
3780finally { 3780;
3781 restoreStackSize(stackSize); 3781finally {
3782} 3782 restoreStackSize(stackSize);
3783 3783}
3784 3784
3785rule__PartialModelSpecification__Group_2__0 3785rule__AllPackageEntry__Group_2__4
3786 @init { 3786 @init {
3787 int stackSize = keepStackSize(); 3787 int stackSize = keepStackSize();
3788 } 3788 }
3789: 3789:
3790 rule__PartialModelSpecification__Group_2__0__Impl 3790 rule__AllPackageEntry__Group_2__4__Impl
3791 rule__PartialModelSpecification__Group_2__1 3791;
3792; 3792finally {
3793finally { 3793 restoreStackSize(stackSize);
3794 restoreStackSize(stackSize); 3794}
3795} 3795
3796 3796rule__AllPackageEntry__Group_2__4__Impl
3797rule__PartialModelSpecification__Group_2__0__Impl 3797 @init {
3798 @init { 3798 int stackSize = keepStackSize();
3799 int stackSize = keepStackSize(); 3799 }
3800 } 3800:
3801: 3801(
3802( 3802 { before(grammarAccess.getAllPackageEntryAccess().getRightCurlyBracketKeyword_2_4()); }
3803 { before(grammarAccess.getPartialModelSpecificationAccess().getCommaKeyword_2_0()); } 3803 '}'
3804 ',' 3804 { after(grammarAccess.getAllPackageEntryAccess().getRightCurlyBracketKeyword_2_4()); }
3805 { after(grammarAccess.getPartialModelSpecificationAccess().getCommaKeyword_2_0()); } 3805)
3806) 3806;
3807; 3807finally {
3808finally { 3808 restoreStackSize(stackSize);
3809 restoreStackSize(stackSize); 3809}
3810} 3810
3811 3811
3812rule__PartialModelSpecification__Group_2__1 3812rule__AllPackageEntry__Group_2_3__0
3813 @init { 3813 @init {
3814 int stackSize = keepStackSize(); 3814 int stackSize = keepStackSize();
3815 } 3815 }
3816: 3816:
3817 rule__PartialModelSpecification__Group_2__1__Impl 3817 rule__AllPackageEntry__Group_2_3__0__Impl
3818; 3818 rule__AllPackageEntry__Group_2_3__1
3819finally { 3819;
3820 restoreStackSize(stackSize); 3820finally {
3821} 3821 restoreStackSize(stackSize);
3822 3822}
3823rule__PartialModelSpecification__Group_2__1__Impl 3823
3824 @init { 3824rule__AllPackageEntry__Group_2_3__0__Impl
3825 int stackSize = keepStackSize(); 3825 @init {
3826 } 3826 int stackSize = keepStackSize();
3827: 3827 }
3828( 3828:
3829 { before(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_2_1()); } 3829(
3830 (rule__PartialModelSpecification__EntryAssignment_2_1) 3830 { before(grammarAccess.getAllPackageEntryAccess().getCommaKeyword_2_3_0()); }
3831 { after(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_2_1()); } 3831 ','
3832) 3832 { after(grammarAccess.getAllPackageEntryAccess().getCommaKeyword_2_3_0()); }
3833; 3833)
3834finally { 3834;
3835 restoreStackSize(stackSize); 3835finally {
3836} 3836 restoreStackSize(stackSize);
3837 3837}
3838 3838
3839rule__FolderEntry__Group__0 3839rule__AllPackageEntry__Group_2_3__1
3840 @init { 3840 @init {
3841 int stackSize = keepStackSize(); 3841 int stackSize = keepStackSize();
3842 } 3842 }
3843: 3843:
3844 rule__FolderEntry__Group__0__Impl 3844 rule__AllPackageEntry__Group_2_3__1__Impl
3845 rule__FolderEntry__Group__1 3845;
3846; 3846finally {
3847finally { 3847 restoreStackSize(stackSize);
3848 restoreStackSize(stackSize); 3848}
3849} 3849
3850 3850rule__AllPackageEntry__Group_2_3__1__Impl
3851rule__FolderEntry__Group__0__Impl 3851 @init {
3852 @init { 3852 int stackSize = keepStackSize();
3853 int stackSize = keepStackSize(); 3853 }
3854 } 3854:
3855: 3855(
3856( 3856 { before(grammarAccess.getAllPackageEntryAccess().getExclusionAssignment_2_3_1()); }
3857 { before(grammarAccess.getFolderEntryAccess().getFolderKeyword_0()); } 3857 (rule__AllPackageEntry__ExclusionAssignment_2_3_1)
3858 'folder' 3858 { after(grammarAccess.getAllPackageEntryAccess().getExclusionAssignment_2_3_1()); }
3859 { after(grammarAccess.getFolderEntryAccess().getFolderKeyword_0()); } 3859)
3860) 3860;
3861; 3861finally {
3862finally { 3862 restoreStackSize(stackSize);
3863 restoreStackSize(stackSize); 3863}
3864} 3864
3865 3865
3866rule__FolderEntry__Group__1 3866rule__MetamodelElement__Group__0
3867 @init { 3867 @init {
3868 int stackSize = keepStackSize(); 3868 int stackSize = keepStackSize();
3869 } 3869 }
3870: 3870:
3871 rule__FolderEntry__Group__1__Impl 3871 rule__MetamodelElement__Group__0__Impl
3872 rule__FolderEntry__Group__2 3872 rule__MetamodelElement__Group__1
3873; 3873;
3874finally { 3874finally {
3875 restoreStackSize(stackSize); 3875 restoreStackSize(stackSize);
3876} 3876}
3877 3877
3878rule__FolderEntry__Group__1__Impl 3878rule__MetamodelElement__Group__0__Impl
3879 @init { 3879 @init {
3880 int stackSize = keepStackSize(); 3880 int stackSize = keepStackSize();
3881 } 3881 }
3882: 3882:
3883( 3883(
3884 { before(grammarAccess.getFolderEntryAccess().getPathAssignment_1()); } 3884 { before(grammarAccess.getMetamodelElementAccess().getGroup_0()); }
3885 (rule__FolderEntry__PathAssignment_1) 3885 (rule__MetamodelElement__Group_0__0)?
3886 { after(grammarAccess.getFolderEntryAccess().getPathAssignment_1()); } 3886 { after(grammarAccess.getMetamodelElementAccess().getGroup_0()); }
3887) 3887)
3888; 3888;
3889finally { 3889finally {
3890 restoreStackSize(stackSize); 3890 restoreStackSize(stackSize);
3891} 3891}
3892 3892
3893rule__FolderEntry__Group__2 3893rule__MetamodelElement__Group__1
3894 @init { 3894 @init {
3895 int stackSize = keepStackSize(); 3895 int stackSize = keepStackSize();
3896 } 3896 }
3897: 3897:
3898 rule__FolderEntry__Group__2__Impl 3898 rule__MetamodelElement__Group__1__Impl
3899; 3899 rule__MetamodelElement__Group__2
3900finally { 3900;
3901 restoreStackSize(stackSize); 3901finally {
3902} 3902 restoreStackSize(stackSize);
3903 3903}
3904rule__FolderEntry__Group__2__Impl 3904
3905 @init { 3905rule__MetamodelElement__Group__1__Impl
3906 int stackSize = keepStackSize(); 3906 @init {
3907 } 3907 int stackSize = keepStackSize();
3908: 3908 }
3909( 3909:
3910 { before(grammarAccess.getFolderEntryAccess().getGroup_2()); } 3910(
3911 (rule__FolderEntry__Group_2__0)? 3911 { before(grammarAccess.getMetamodelElementAccess().getClassifierAssignment_1()); }
3912 { after(grammarAccess.getFolderEntryAccess().getGroup_2()); } 3912 (rule__MetamodelElement__ClassifierAssignment_1)
3913) 3913 { after(grammarAccess.getMetamodelElementAccess().getClassifierAssignment_1()); }
3914; 3914)
3915finally { 3915;
3916 restoreStackSize(stackSize); 3916finally {
3917} 3917 restoreStackSize(stackSize);
3918 3918}
3919 3919
3920rule__FolderEntry__Group_2__0 3920rule__MetamodelElement__Group__2
3921 @init { 3921 @init {
3922 int stackSize = keepStackSize(); 3922 int stackSize = keepStackSize();
3923 } 3923 }
3924: 3924:
3925 rule__FolderEntry__Group_2__0__Impl 3925 rule__MetamodelElement__Group__2__Impl
3926 rule__FolderEntry__Group_2__1 3926;
3927; 3927finally {
3928finally { 3928 restoreStackSize(stackSize);
3929 restoreStackSize(stackSize); 3929}
3930} 3930
3931 3931rule__MetamodelElement__Group__2__Impl
3932rule__FolderEntry__Group_2__0__Impl 3932 @init {
3933 @init { 3933 int stackSize = keepStackSize();
3934 int stackSize = keepStackSize(); 3934 }
3935 } 3935:
3936: 3936(
3937( 3937 { before(grammarAccess.getMetamodelElementAccess().getGroup_2()); }
3938 { before(grammarAccess.getFolderEntryAccess().getExcludingKeyword_2_0()); } 3938 (rule__MetamodelElement__Group_2__0)?
3939 'excluding' 3939 { after(grammarAccess.getMetamodelElementAccess().getGroup_2()); }
3940 { after(grammarAccess.getFolderEntryAccess().getExcludingKeyword_2_0()); } 3940)
3941) 3941;
3942; 3942finally {
3943finally { 3943 restoreStackSize(stackSize);
3944 restoreStackSize(stackSize); 3944}
3945} 3945
3946 3946
3947rule__FolderEntry__Group_2__1 3947rule__MetamodelElement__Group_0__0
3948 @init { 3948 @init {
3949 int stackSize = keepStackSize(); 3949 int stackSize = keepStackSize();
3950 } 3950 }
3951: 3951:
3952 rule__FolderEntry__Group_2__1__Impl 3952 rule__MetamodelElement__Group_0__0__Impl
3953 rule__FolderEntry__Group_2__2 3953 rule__MetamodelElement__Group_0__1
3954; 3954;
3955finally { 3955finally {
3956 restoreStackSize(stackSize); 3956 restoreStackSize(stackSize);
3957} 3957}
3958 3958
3959rule__FolderEntry__Group_2__1__Impl 3959rule__MetamodelElement__Group_0__0__Impl
3960 @init { 3960 @init {
3961 int stackSize = keepStackSize(); 3961 int stackSize = keepStackSize();
3962 } 3962 }
3963: 3963:
3964( 3964(
3965 { before(grammarAccess.getFolderEntryAccess().getLeftCurlyBracketKeyword_2_1()); } 3965 { before(grammarAccess.getMetamodelElementAccess().getPackageAssignment_0_0()); }
3966 '{' 3966 (rule__MetamodelElement__PackageAssignment_0_0)
3967 { after(grammarAccess.getFolderEntryAccess().getLeftCurlyBracketKeyword_2_1()); } 3967 { after(grammarAccess.getMetamodelElementAccess().getPackageAssignment_0_0()); }
3968) 3968)
3969; 3969;
3970finally { 3970finally {
3971 restoreStackSize(stackSize); 3971 restoreStackSize(stackSize);
3972} 3972}
3973 3973
3974rule__FolderEntry__Group_2__2 3974rule__MetamodelElement__Group_0__1
3975 @init { 3975 @init {
3976 int stackSize = keepStackSize(); 3976 int stackSize = keepStackSize();
3977 } 3977 }
3978: 3978:
3979 rule__FolderEntry__Group_2__2__Impl 3979 rule__MetamodelElement__Group_0__1__Impl
3980 rule__FolderEntry__Group_2__3 3980;
3981; 3981finally {
3982finally { 3982 restoreStackSize(stackSize);
3983 restoreStackSize(stackSize); 3983}
3984} 3984
3985 3985rule__MetamodelElement__Group_0__1__Impl
3986rule__FolderEntry__Group_2__2__Impl 3986 @init {
3987 @init { 3987 int stackSize = keepStackSize();
3988 int stackSize = keepStackSize(); 3988 }
3989 } 3989:
3990: 3990(
3991( 3991 { before(grammarAccess.getMetamodelElementAccess().getColonColonKeyword_0_1()); }
3992 { before(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_2()); } 3992 '::'
3993 (rule__FolderEntry__ExclusionAssignment_2_2) 3993 { after(grammarAccess.getMetamodelElementAccess().getColonColonKeyword_0_1()); }
3994 { after(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_2()); } 3994)
3995) 3995;
3996; 3996finally {
3997finally { 3997 restoreStackSize(stackSize);
3998 restoreStackSize(stackSize); 3998}
3999} 3999
4000 4000
4001rule__FolderEntry__Group_2__3 4001rule__MetamodelElement__Group_2__0
4002 @init { 4002 @init {
4003 int stackSize = keepStackSize(); 4003 int stackSize = keepStackSize();
4004 } 4004 }
4005: 4005:
4006 rule__FolderEntry__Group_2__3__Impl 4006 rule__MetamodelElement__Group_2__0__Impl
4007 rule__FolderEntry__Group_2__4 4007 rule__MetamodelElement__Group_2__1
4008; 4008;
4009finally { 4009finally {
4010 restoreStackSize(stackSize); 4010 restoreStackSize(stackSize);
4011} 4011}
4012 4012
4013rule__FolderEntry__Group_2__3__Impl 4013rule__MetamodelElement__Group_2__0__Impl
4014 @init { 4014 @init {
4015 int stackSize = keepStackSize(); 4015 int stackSize = keepStackSize();
4016 } 4016 }
4017: 4017:
4018( 4018(
4019 { before(grammarAccess.getFolderEntryAccess().getGroup_2_3()); } 4019 { before(grammarAccess.getMetamodelElementAccess().getFullStopKeyword_2_0()); }
4020 (rule__FolderEntry__Group_2_3__0)* 4020 '.'
4021 { after(grammarAccess.getFolderEntryAccess().getGroup_2_3()); } 4021 { after(grammarAccess.getMetamodelElementAccess().getFullStopKeyword_2_0()); }
4022) 4022)
4023; 4023;
4024finally { 4024finally {
4025 restoreStackSize(stackSize); 4025 restoreStackSize(stackSize);
4026} 4026}
4027 4027
4028rule__FolderEntry__Group_2__4 4028rule__MetamodelElement__Group_2__1
4029 @init { 4029 @init {
4030 int stackSize = keepStackSize(); 4030 int stackSize = keepStackSize();
4031 } 4031 }
4032: 4032:
4033 rule__FolderEntry__Group_2__4__Impl 4033 rule__MetamodelElement__Group_2__1__Impl
4034; 4034;
4035finally { 4035finally {
4036 restoreStackSize(stackSize); 4036 restoreStackSize(stackSize);
4037} 4037}
4038 4038
4039rule__FolderEntry__Group_2__4__Impl 4039rule__MetamodelElement__Group_2__1__Impl
4040 @init { 4040 @init {
4041 int stackSize = keepStackSize(); 4041 int stackSize = keepStackSize();
4042 } 4042 }
4043: 4043:
4044( 4044(
4045 { before(grammarAccess.getFolderEntryAccess().getRightCurlyBracketKeyword_2_4()); } 4045 { before(grammarAccess.getMetamodelElementAccess().getFeatureAssignment_2_1()); }
4046 '}' 4046 (rule__MetamodelElement__FeatureAssignment_2_1)
4047 { after(grammarAccess.getFolderEntryAccess().getRightCurlyBracketKeyword_2_4()); } 4047 { after(grammarAccess.getMetamodelElementAccess().getFeatureAssignment_2_1()); }
4048) 4048)
4049; 4049;
4050finally { 4050finally {
4051 restoreStackSize(stackSize); 4051 restoreStackSize(stackSize);
4052} 4052}
4053 4053
4054 4054
4055rule__FolderEntry__Group_2_3__0 4055rule__MetamodelDeclaration__Group__0
4056 @init { 4056 @init {
4057 int stackSize = keepStackSize(); 4057 int stackSize = keepStackSize();
4058 } 4058 }
4059: 4059:
4060 rule__FolderEntry__Group_2_3__0__Impl 4060 rule__MetamodelDeclaration__Group__0__Impl
4061 rule__FolderEntry__Group_2_3__1 4061 rule__MetamodelDeclaration__Group__1
4062; 4062;
4063finally { 4063finally {
4064 restoreStackSize(stackSize); 4064 restoreStackSize(stackSize);
4065} 4065}
4066 4066
4067rule__FolderEntry__Group_2_3__0__Impl 4067rule__MetamodelDeclaration__Group__0__Impl
4068 @init { 4068 @init {
4069 int stackSize = keepStackSize(); 4069 int stackSize = keepStackSize();
4070 } 4070 }
4071: 4071:
4072( 4072(
4073 { before(grammarAccess.getFolderEntryAccess().getCommaKeyword_2_3_0()); } 4073 { before(grammarAccess.getMetamodelDeclarationAccess().getMetamodelKeyword_0()); }
4074 ',' 4074 'metamodel'
4075 { after(grammarAccess.getFolderEntryAccess().getCommaKeyword_2_3_0()); } 4075 { after(grammarAccess.getMetamodelDeclarationAccess().getMetamodelKeyword_0()); }
4076) 4076)
4077; 4077;
4078finally { 4078finally {
4079 restoreStackSize(stackSize); 4079 restoreStackSize(stackSize);
4080} 4080}
4081 4081
4082rule__FolderEntry__Group_2_3__1 4082rule__MetamodelDeclaration__Group__1
4083 @init { 4083 @init {
4084 int stackSize = keepStackSize(); 4084 int stackSize = keepStackSize();
4085 } 4085 }
4086: 4086:
4087 rule__FolderEntry__Group_2_3__1__Impl 4087 rule__MetamodelDeclaration__Group__1__Impl
4088; 4088 rule__MetamodelDeclaration__Group__2
4089finally { 4089;
4090 restoreStackSize(stackSize); 4090finally {
4091} 4091 restoreStackSize(stackSize);
4092 4092}
4093rule__FolderEntry__Group_2_3__1__Impl 4093
4094 @init { 4094rule__MetamodelDeclaration__Group__1__Impl
4095 int stackSize = keepStackSize(); 4095 @init {
4096 } 4096 int stackSize = keepStackSize();
4097: 4097 }
4098( 4098:
4099 { before(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_3_1()); } 4099(
4100 (rule__FolderEntry__ExclusionAssignment_2_3_1) 4100 { before(grammarAccess.getMetamodelDeclarationAccess().getNameAssignment_1()); }
4101 { after(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_3_1()); } 4101 (rule__MetamodelDeclaration__NameAssignment_1)
4102) 4102 { after(grammarAccess.getMetamodelDeclarationAccess().getNameAssignment_1()); }
4103; 4103)
4104finally { 4104;
4105 restoreStackSize(stackSize); 4105finally {
4106} 4106 restoreStackSize(stackSize);
4107 4107}
4108 4108
4109rule__PartialModelDeclaration__Group__0 4109rule__MetamodelDeclaration__Group__2
4110 @init { 4110 @init {
4111 int stackSize = keepStackSize(); 4111 int stackSize = keepStackSize();
4112 } 4112 }
4113: 4113:
4114 rule__PartialModelDeclaration__Group__0__Impl 4114 rule__MetamodelDeclaration__Group__2__Impl
4115 rule__PartialModelDeclaration__Group__1 4115;
4116; 4116finally {
4117finally { 4117 restoreStackSize(stackSize);
4118 restoreStackSize(stackSize); 4118}
4119} 4119
4120 4120rule__MetamodelDeclaration__Group__2__Impl
4121rule__PartialModelDeclaration__Group__0__Impl 4121 @init {
4122 @init { 4122 int stackSize = keepStackSize();
4123 int stackSize = keepStackSize(); 4123 }
4124 } 4124:
4125: 4125(
4126( 4126 { before(grammarAccess.getMetamodelDeclarationAccess().getSpecificationAssignment_2()); }
4127 { before(grammarAccess.getPartialModelDeclarationAccess().getModelsKeyword_0()); } 4127 (rule__MetamodelDeclaration__SpecificationAssignment_2)
4128 'models' 4128 { after(grammarAccess.getMetamodelDeclarationAccess().getSpecificationAssignment_2()); }
4129 { after(grammarAccess.getPartialModelDeclarationAccess().getModelsKeyword_0()); } 4129)
4130) 4130;
4131; 4131finally {
4132finally { 4132 restoreStackSize(stackSize);
4133 restoreStackSize(stackSize); 4133}
4134} 4134
4135 4135
4136rule__PartialModelDeclaration__Group__1 4136rule__PartialModelSpecification__Group__0
4137 @init { 4137 @init {
4138 int stackSize = keepStackSize(); 4138 int stackSize = keepStackSize();
4139 } 4139 }
4140: 4140:
4141 rule__PartialModelDeclaration__Group__1__Impl 4141 rule__PartialModelSpecification__Group__0__Impl
4142 rule__PartialModelDeclaration__Group__2 4142 rule__PartialModelSpecification__Group__1
4143; 4143;
4144finally { 4144finally {
4145 restoreStackSize(stackSize); 4145 restoreStackSize(stackSize);
4146} 4146}
4147 4147
4148rule__PartialModelDeclaration__Group__1__Impl 4148rule__PartialModelSpecification__Group__0__Impl
4149 @init { 4149 @init {
4150 int stackSize = keepStackSize(); 4150 int stackSize = keepStackSize();
4151 } 4151 }
4152: 4152:
4153( 4153(
4154 { before(grammarAccess.getPartialModelDeclarationAccess().getNameAssignment_1()); } 4154 { before(grammarAccess.getPartialModelSpecificationAccess().getLeftCurlyBracketKeyword_0()); }
4155 (rule__PartialModelDeclaration__NameAssignment_1) 4155 '{'
4156 { after(grammarAccess.getPartialModelDeclarationAccess().getNameAssignment_1()); } 4156 { after(grammarAccess.getPartialModelSpecificationAccess().getLeftCurlyBracketKeyword_0()); }
4157) 4157)
4158; 4158;
4159finally { 4159finally {
4160 restoreStackSize(stackSize); 4160 restoreStackSize(stackSize);
4161} 4161}
4162 4162
4163rule__PartialModelDeclaration__Group__2 4163rule__PartialModelSpecification__Group__1
4164 @init { 4164 @init {
4165 int stackSize = keepStackSize(); 4165 int stackSize = keepStackSize();
4166 } 4166 }
4167: 4167:
4168 rule__PartialModelDeclaration__Group__2__Impl 4168 rule__PartialModelSpecification__Group__1__Impl
4169; 4169 rule__PartialModelSpecification__Group__2
4170finally { 4170;
4171 restoreStackSize(stackSize); 4171finally {
4172} 4172 restoreStackSize(stackSize);
4173 4173}
4174rule__PartialModelDeclaration__Group__2__Impl 4174
4175 @init { 4175rule__PartialModelSpecification__Group__1__Impl
4176 int stackSize = keepStackSize(); 4176 @init {
4177 } 4177 int stackSize = keepStackSize();
4178: 4178 }
4179( 4179:
4180 { before(grammarAccess.getPartialModelDeclarationAccess().getSpecificationAssignment_2()); } 4180(
4181 (rule__PartialModelDeclaration__SpecificationAssignment_2) 4181 { before(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_1()); }
4182 { after(grammarAccess.getPartialModelDeclarationAccess().getSpecificationAssignment_2()); } 4182 (rule__PartialModelSpecification__EntryAssignment_1)
4183) 4183 { after(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_1()); }
4184; 4184)
4185finally { 4185;
4186 restoreStackSize(stackSize); 4186finally {
4187} 4187 restoreStackSize(stackSize);
4188 4188}
4189 4189
4190rule__PatternSpecification__Group__0 4190rule__PartialModelSpecification__Group__2
4191 @init { 4191 @init {
4192 int stackSize = keepStackSize(); 4192 int stackSize = keepStackSize();
4193 } 4193 }
4194: 4194:
4195 rule__PatternSpecification__Group__0__Impl 4195 rule__PartialModelSpecification__Group__2__Impl
4196 rule__PatternSpecification__Group__1 4196 rule__PartialModelSpecification__Group__3
4197; 4197;
4198finally { 4198finally {
4199 restoreStackSize(stackSize); 4199 restoreStackSize(stackSize);
4200} 4200}
4201 4201
4202rule__PatternSpecification__Group__0__Impl 4202rule__PartialModelSpecification__Group__2__Impl
4203 @init { 4203 @init {
4204 int stackSize = keepStackSize(); 4204 int stackSize = keepStackSize();
4205 } 4205 }
4206: 4206:
4207( 4207(
4208 { before(grammarAccess.getPatternSpecificationAccess().getLeftCurlyBracketKeyword_0()); } 4208 { before(grammarAccess.getPartialModelSpecificationAccess().getGroup_2()); }
4209 '{' 4209 (rule__PartialModelSpecification__Group_2__0)?
4210 { after(grammarAccess.getPatternSpecificationAccess().getLeftCurlyBracketKeyword_0()); } 4210 { after(grammarAccess.getPartialModelSpecificationAccess().getGroup_2()); }
4211) 4211)
4212; 4212;
4213finally { 4213finally {
4214 restoreStackSize(stackSize); 4214 restoreStackSize(stackSize);
4215} 4215}
4216 4216
4217rule__PatternSpecification__Group__1 4217rule__PartialModelSpecification__Group__3
4218 @init { 4218 @init {
4219 int stackSize = keepStackSize(); 4219 int stackSize = keepStackSize();
4220 } 4220 }
4221: 4221:
4222 rule__PatternSpecification__Group__1__Impl 4222 rule__PartialModelSpecification__Group__3__Impl
4223 rule__PatternSpecification__Group__2 4223;
4224; 4224finally {
4225finally { 4225 restoreStackSize(stackSize);
4226 restoreStackSize(stackSize); 4226}
4227} 4227
4228 4228rule__PartialModelSpecification__Group__3__Impl
4229rule__PatternSpecification__Group__1__Impl 4229 @init {
4230 @init { 4230 int stackSize = keepStackSize();
4231 int stackSize = keepStackSize(); 4231 }
4232 } 4232:
4233: 4233(
4234( 4234 { before(grammarAccess.getPartialModelSpecificationAccess().getRightCurlyBracketKeyword_3()); }
4235 { before(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_1()); } 4235 '}'
4236 (rule__PatternSpecification__EntriesAssignment_1) 4236 { after(grammarAccess.getPartialModelSpecificationAccess().getRightCurlyBracketKeyword_3()); }
4237 { after(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_1()); } 4237)
4238) 4238;
4239; 4239finally {
4240finally { 4240 restoreStackSize(stackSize);
4241 restoreStackSize(stackSize); 4241}
4242} 4242
4243 4243
4244rule__PatternSpecification__Group__2 4244rule__PartialModelSpecification__Group_2__0
4245 @init { 4245 @init {
4246 int stackSize = keepStackSize(); 4246 int stackSize = keepStackSize();
4247 } 4247 }
4248: 4248:
4249 rule__PatternSpecification__Group__2__Impl 4249 rule__PartialModelSpecification__Group_2__0__Impl
4250 rule__PatternSpecification__Group__3 4250 rule__PartialModelSpecification__Group_2__1
4251; 4251;
4252finally { 4252finally {
4253 restoreStackSize(stackSize); 4253 restoreStackSize(stackSize);
4254} 4254}
4255 4255
4256rule__PatternSpecification__Group__2__Impl 4256rule__PartialModelSpecification__Group_2__0__Impl
4257 @init { 4257 @init {
4258 int stackSize = keepStackSize(); 4258 int stackSize = keepStackSize();
4259 } 4259 }
4260: 4260:
4261( 4261(
4262 { before(grammarAccess.getPatternSpecificationAccess().getGroup_2()); } 4262 { before(grammarAccess.getPartialModelSpecificationAccess().getCommaKeyword_2_0()); }
4263 (rule__PatternSpecification__Group_2__0)* 4263 ','
4264 { after(grammarAccess.getPatternSpecificationAccess().getGroup_2()); } 4264 { after(grammarAccess.getPartialModelSpecificationAccess().getCommaKeyword_2_0()); }
4265) 4265)
4266; 4266;
4267finally { 4267finally {
4268 restoreStackSize(stackSize); 4268 restoreStackSize(stackSize);
4269} 4269}
4270 4270
4271rule__PatternSpecification__Group__3 4271rule__PartialModelSpecification__Group_2__1
4272 @init { 4272 @init {
4273 int stackSize = keepStackSize(); 4273 int stackSize = keepStackSize();
4274 } 4274 }
4275: 4275:
4276 rule__PatternSpecification__Group__3__Impl 4276 rule__PartialModelSpecification__Group_2__1__Impl
4277; 4277;
4278finally { 4278finally {
4279 restoreStackSize(stackSize); 4279 restoreStackSize(stackSize);
4280} 4280}
4281 4281
4282rule__PatternSpecification__Group__3__Impl 4282rule__PartialModelSpecification__Group_2__1__Impl
4283 @init { 4283 @init {
4284 int stackSize = keepStackSize(); 4284 int stackSize = keepStackSize();
4285 } 4285 }
4286: 4286:
4287( 4287(
4288 { before(grammarAccess.getPatternSpecificationAccess().getRightCurlyBracketKeyword_3()); } 4288 { before(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_2_1()); }
4289 '}' 4289 (rule__PartialModelSpecification__EntryAssignment_2_1)
4290 { after(grammarAccess.getPatternSpecificationAccess().getRightCurlyBracketKeyword_3()); } 4290 { after(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_2_1()); }
4291) 4291)
4292; 4292;
4293finally { 4293finally {
4294 restoreStackSize(stackSize); 4294 restoreStackSize(stackSize);
4295} 4295}
4296 4296
4297 4297
4298rule__PatternSpecification__Group_2__0 4298rule__FolderEntry__Group__0
4299 @init { 4299 @init {
4300 int stackSize = keepStackSize(); 4300 int stackSize = keepStackSize();
4301 } 4301 }
4302: 4302:
4303 rule__PatternSpecification__Group_2__0__Impl 4303 rule__FolderEntry__Group__0__Impl
4304 rule__PatternSpecification__Group_2__1 4304 rule__FolderEntry__Group__1
4305; 4305;
4306finally { 4306finally {
4307 restoreStackSize(stackSize); 4307 restoreStackSize(stackSize);
4308} 4308}
4309 4309
4310rule__PatternSpecification__Group_2__0__Impl 4310rule__FolderEntry__Group__0__Impl
4311 @init { 4311 @init {
4312 int stackSize = keepStackSize(); 4312 int stackSize = keepStackSize();
4313 } 4313 }
4314: 4314:
4315( 4315(
4316 { before(grammarAccess.getPatternSpecificationAccess().getCommaKeyword_2_0()); } 4316 { before(grammarAccess.getFolderEntryAccess().getFolderKeyword_0()); }
4317 ',' 4317 'folder'
4318 { after(grammarAccess.getPatternSpecificationAccess().getCommaKeyword_2_0()); } 4318 { after(grammarAccess.getFolderEntryAccess().getFolderKeyword_0()); }
4319) 4319)
4320; 4320;
4321finally { 4321finally {
4322 restoreStackSize(stackSize); 4322 restoreStackSize(stackSize);
4323} 4323}
4324 4324
4325rule__PatternSpecification__Group_2__1 4325rule__FolderEntry__Group__1
4326 @init { 4326 @init {
4327 int stackSize = keepStackSize(); 4327 int stackSize = keepStackSize();
4328 } 4328 }
4329: 4329:
4330 rule__PatternSpecification__Group_2__1__Impl 4330 rule__FolderEntry__Group__1__Impl
4331; 4331 rule__FolderEntry__Group__2
4332finally { 4332;
4333 restoreStackSize(stackSize); 4333finally {
4334} 4334 restoreStackSize(stackSize);
4335 4335}
4336rule__PatternSpecification__Group_2__1__Impl 4336
4337 @init { 4337rule__FolderEntry__Group__1__Impl
4338 int stackSize = keepStackSize(); 4338 @init {
4339 } 4339 int stackSize = keepStackSize();
4340: 4340 }
4341( 4341:
4342 { before(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_2_1()); } 4342(
4343 (rule__PatternSpecification__EntriesAssignment_2_1) 4343 { before(grammarAccess.getFolderEntryAccess().getPathAssignment_1()); }
4344 { after(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_2_1()); } 4344 (rule__FolderEntry__PathAssignment_1)
4345) 4345 { after(grammarAccess.getFolderEntryAccess().getPathAssignment_1()); }
4346; 4346)
4347finally { 4347;
4348 restoreStackSize(stackSize); 4348finally {
4349} 4349 restoreStackSize(stackSize);
4350 4350}
4351 4351
4352rule__AllPatternEntry__Group__0 4352rule__FolderEntry__Group__2
4353 @init { 4353 @init {
4354 int stackSize = keepStackSize(); 4354 int stackSize = keepStackSize();
4355 } 4355 }
4356: 4356:
4357 rule__AllPatternEntry__Group__0__Impl 4357 rule__FolderEntry__Group__2__Impl
4358 rule__AllPatternEntry__Group__1 4358;
4359; 4359finally {
4360finally { 4360 restoreStackSize(stackSize);
4361 restoreStackSize(stackSize); 4361}
4362} 4362
4363 4363rule__FolderEntry__Group__2__Impl
4364rule__AllPatternEntry__Group__0__Impl 4364 @init {
4365 @init { 4365 int stackSize = keepStackSize();
4366 int stackSize = keepStackSize(); 4366 }
4367 } 4367:
4368: 4368(
4369( 4369 { before(grammarAccess.getFolderEntryAccess().getGroup_2()); }
4370 { before(grammarAccess.getAllPatternEntryAccess().getPackageKeyword_0()); } 4370 (rule__FolderEntry__Group_2__0)?
4371 'package' 4371 { after(grammarAccess.getFolderEntryAccess().getGroup_2()); }
4372 { after(grammarAccess.getAllPatternEntryAccess().getPackageKeyword_0()); } 4372)
4373) 4373;
4374; 4374finally {
4375finally { 4375 restoreStackSize(stackSize);
4376 restoreStackSize(stackSize); 4376}
4377} 4377
4378 4378
4379rule__AllPatternEntry__Group__1 4379rule__FolderEntry__Group_2__0
4380 @init { 4380 @init {
4381 int stackSize = keepStackSize(); 4381 int stackSize = keepStackSize();
4382 } 4382 }
4383: 4383:
4384 rule__AllPatternEntry__Group__1__Impl 4384 rule__FolderEntry__Group_2__0__Impl
4385 rule__AllPatternEntry__Group__2 4385 rule__FolderEntry__Group_2__1
4386; 4386;
4387finally { 4387finally {
4388 restoreStackSize(stackSize); 4388 restoreStackSize(stackSize);
4389} 4389}
4390 4390
4391rule__AllPatternEntry__Group__1__Impl 4391rule__FolderEntry__Group_2__0__Impl
4392 @init { 4392 @init {
4393 int stackSize = keepStackSize(); 4393 int stackSize = keepStackSize();
4394 } 4394 }
4395: 4395:
4396( 4396(
4397 { before(grammarAccess.getAllPatternEntryAccess().getPackageAssignment_1()); } 4397 { before(grammarAccess.getFolderEntryAccess().getExcludingKeyword_2_0()); }
4398 (rule__AllPatternEntry__PackageAssignment_1) 4398 'excluding'
4399 { after(grammarAccess.getAllPatternEntryAccess().getPackageAssignment_1()); } 4399 { after(grammarAccess.getFolderEntryAccess().getExcludingKeyword_2_0()); }
4400) 4400)
4401; 4401;
4402finally { 4402finally {
4403 restoreStackSize(stackSize); 4403 restoreStackSize(stackSize);
4404} 4404}
4405 4405
4406rule__AllPatternEntry__Group__2 4406rule__FolderEntry__Group_2__1
4407 @init { 4407 @init {
4408 int stackSize = keepStackSize(); 4408 int stackSize = keepStackSize();
4409 } 4409 }
4410: 4410:
4411 rule__AllPatternEntry__Group__2__Impl 4411 rule__FolderEntry__Group_2__1__Impl
4412; 4412 rule__FolderEntry__Group_2__2
4413finally { 4413;
4414 restoreStackSize(stackSize); 4414finally {
4415} 4415 restoreStackSize(stackSize);
4416 4416}
4417rule__AllPatternEntry__Group__2__Impl 4417
4418 @init { 4418rule__FolderEntry__Group_2__1__Impl
4419 int stackSize = keepStackSize(); 4419 @init {
4420 } 4420 int stackSize = keepStackSize();
4421: 4421 }
4422( 4422:
4423 { before(grammarAccess.getAllPatternEntryAccess().getGroup_2()); } 4423(
4424 (rule__AllPatternEntry__Group_2__0)? 4424 { before(grammarAccess.getFolderEntryAccess().getLeftCurlyBracketKeyword_2_1()); }
4425 { after(grammarAccess.getAllPatternEntryAccess().getGroup_2()); } 4425 '{'
4426) 4426 { after(grammarAccess.getFolderEntryAccess().getLeftCurlyBracketKeyword_2_1()); }
4427; 4427)
4428finally { 4428;
4429 restoreStackSize(stackSize); 4429finally {
4430} 4430 restoreStackSize(stackSize);
4431 4431}
4432 4432
4433rule__AllPatternEntry__Group_2__0 4433rule__FolderEntry__Group_2__2
4434 @init { 4434 @init {
4435 int stackSize = keepStackSize(); 4435 int stackSize = keepStackSize();
4436 } 4436 }
4437: 4437:
4438 rule__AllPatternEntry__Group_2__0__Impl 4438 rule__FolderEntry__Group_2__2__Impl
4439 rule__AllPatternEntry__Group_2__1 4439 rule__FolderEntry__Group_2__3
4440; 4440;
4441finally { 4441finally {
4442 restoreStackSize(stackSize); 4442 restoreStackSize(stackSize);
4443} 4443}
4444 4444
4445rule__AllPatternEntry__Group_2__0__Impl 4445rule__FolderEntry__Group_2__2__Impl
4446 @init { 4446 @init {
4447 int stackSize = keepStackSize(); 4447 int stackSize = keepStackSize();
4448 } 4448 }
4449: 4449:
4450( 4450(
4451 { before(grammarAccess.getAllPatternEntryAccess().getExcludingKeyword_2_0()); } 4451 { before(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_2()); }
4452 'excluding' 4452 (rule__FolderEntry__ExclusionAssignment_2_2)
4453 { after(grammarAccess.getAllPatternEntryAccess().getExcludingKeyword_2_0()); } 4453 { after(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_2()); }
4454) 4454)
4455; 4455;
4456finally { 4456finally {
4457 restoreStackSize(stackSize); 4457 restoreStackSize(stackSize);
4458} 4458}
4459 4459
4460rule__AllPatternEntry__Group_2__1 4460rule__FolderEntry__Group_2__3
4461 @init { 4461 @init {
4462 int stackSize = keepStackSize(); 4462 int stackSize = keepStackSize();
4463 } 4463 }
4464: 4464:
4465 rule__AllPatternEntry__Group_2__1__Impl 4465 rule__FolderEntry__Group_2__3__Impl
4466 rule__AllPatternEntry__Group_2__2 4466 rule__FolderEntry__Group_2__4
4467; 4467;
4468finally { 4468finally {
4469 restoreStackSize(stackSize); 4469 restoreStackSize(stackSize);
4470} 4470}
4471 4471
4472rule__AllPatternEntry__Group_2__1__Impl 4472rule__FolderEntry__Group_2__3__Impl
4473 @init { 4473 @init {
4474 int stackSize = keepStackSize(); 4474 int stackSize = keepStackSize();
4475 } 4475 }
4476: 4476:
4477( 4477(
4478 { before(grammarAccess.getAllPatternEntryAccess().getLeftCurlyBracketKeyword_2_1()); } 4478 { before(grammarAccess.getFolderEntryAccess().getGroup_2_3()); }
4479 '{' 4479 (rule__FolderEntry__Group_2_3__0)*
4480 { after(grammarAccess.getAllPatternEntryAccess().getLeftCurlyBracketKeyword_2_1()); } 4480 { after(grammarAccess.getFolderEntryAccess().getGroup_2_3()); }
4481) 4481)
4482; 4482;
4483finally { 4483finally {
4484 restoreStackSize(stackSize); 4484 restoreStackSize(stackSize);
4485} 4485}
4486 4486
4487rule__AllPatternEntry__Group_2__2 4487rule__FolderEntry__Group_2__4
4488 @init { 4488 @init {
4489 int stackSize = keepStackSize(); 4489 int stackSize = keepStackSize();
4490 } 4490 }
4491: 4491:
4492 rule__AllPatternEntry__Group_2__2__Impl 4492 rule__FolderEntry__Group_2__4__Impl
4493 rule__AllPatternEntry__Group_2__3 4493;
4494; 4494finally {
4495finally { 4495 restoreStackSize(stackSize);
4496 restoreStackSize(stackSize); 4496}
4497} 4497
4498 4498rule__FolderEntry__Group_2__4__Impl
4499rule__AllPatternEntry__Group_2__2__Impl 4499 @init {
4500 @init { 4500 int stackSize = keepStackSize();
4501 int stackSize = keepStackSize(); 4501 }
4502 } 4502:
4503: 4503(
4504( 4504 { before(grammarAccess.getFolderEntryAccess().getRightCurlyBracketKeyword_2_4()); }
4505 { before(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_2()); } 4505 '}'
4506 (rule__AllPatternEntry__ExclusuionAssignment_2_2) 4506 { after(grammarAccess.getFolderEntryAccess().getRightCurlyBracketKeyword_2_4()); }
4507 { after(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_2()); } 4507)
4508) 4508;
4509; 4509finally {
4510finally { 4510 restoreStackSize(stackSize);
4511 restoreStackSize(stackSize); 4511}
4512} 4512
4513 4513
4514rule__AllPatternEntry__Group_2__3 4514rule__FolderEntry__Group_2_3__0
4515 @init { 4515 @init {
4516 int stackSize = keepStackSize(); 4516 int stackSize = keepStackSize();
4517 } 4517 }
4518: 4518:
4519 rule__AllPatternEntry__Group_2__3__Impl 4519 rule__FolderEntry__Group_2_3__0__Impl
4520 rule__AllPatternEntry__Group_2__4 4520 rule__FolderEntry__Group_2_3__1
4521; 4521;
4522finally { 4522finally {
4523 restoreStackSize(stackSize); 4523 restoreStackSize(stackSize);
4524} 4524}
4525 4525
4526rule__AllPatternEntry__Group_2__3__Impl 4526rule__FolderEntry__Group_2_3__0__Impl
4527 @init { 4527 @init {
4528 int stackSize = keepStackSize(); 4528 int stackSize = keepStackSize();
4529 } 4529 }
4530: 4530:
4531( 4531(
4532 { before(grammarAccess.getAllPatternEntryAccess().getGroup_2_3()); } 4532 { before(grammarAccess.getFolderEntryAccess().getCommaKeyword_2_3_0()); }
4533 (rule__AllPatternEntry__Group_2_3__0)* 4533 ','
4534 { after(grammarAccess.getAllPatternEntryAccess().getGroup_2_3()); } 4534 { after(grammarAccess.getFolderEntryAccess().getCommaKeyword_2_3_0()); }
4535) 4535)
4536; 4536;
4537finally { 4537finally {
4538 restoreStackSize(stackSize); 4538 restoreStackSize(stackSize);
4539} 4539}
4540 4540
4541rule__AllPatternEntry__Group_2__4 4541rule__FolderEntry__Group_2_3__1
4542 @init { 4542 @init {
4543 int stackSize = keepStackSize(); 4543 int stackSize = keepStackSize();
4544 } 4544 }
4545: 4545:
4546 rule__AllPatternEntry__Group_2__4__Impl 4546 rule__FolderEntry__Group_2_3__1__Impl
4547; 4547;
4548finally { 4548finally {
4549 restoreStackSize(stackSize); 4549 restoreStackSize(stackSize);
4550} 4550}
4551 4551
4552rule__AllPatternEntry__Group_2__4__Impl 4552rule__FolderEntry__Group_2_3__1__Impl
4553 @init { 4553 @init {
4554 int stackSize = keepStackSize(); 4554 int stackSize = keepStackSize();
4555 } 4555 }
4556: 4556:
4557( 4557(
4558 { before(grammarAccess.getAllPatternEntryAccess().getRightCurlyBracketKeyword_2_4()); } 4558 { before(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_3_1()); }
4559 '}' 4559 (rule__FolderEntry__ExclusionAssignment_2_3_1)
4560 { after(grammarAccess.getAllPatternEntryAccess().getRightCurlyBracketKeyword_2_4()); } 4560 { after(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_3_1()); }
4561) 4561)
4562; 4562;
4563finally { 4563finally {
4564 restoreStackSize(stackSize); 4564 restoreStackSize(stackSize);
4565} 4565}
4566 4566
4567 4567
4568rule__AllPatternEntry__Group_2_3__0 4568rule__PartialModelDeclaration__Group__0
4569 @init { 4569 @init {
4570 int stackSize = keepStackSize(); 4570 int stackSize = keepStackSize();
4571 } 4571 }
4572: 4572:
4573 rule__AllPatternEntry__Group_2_3__0__Impl 4573 rule__PartialModelDeclaration__Group__0__Impl
4574 rule__AllPatternEntry__Group_2_3__1 4574 rule__PartialModelDeclaration__Group__1
4575; 4575;
4576finally { 4576finally {
4577 restoreStackSize(stackSize); 4577 restoreStackSize(stackSize);
4578} 4578}
4579 4579
4580rule__AllPatternEntry__Group_2_3__0__Impl 4580rule__PartialModelDeclaration__Group__0__Impl
4581 @init { 4581 @init {
4582 int stackSize = keepStackSize(); 4582 int stackSize = keepStackSize();
4583 } 4583 }
4584: 4584:
4585( 4585(
4586 { before(grammarAccess.getAllPatternEntryAccess().getCommaKeyword_2_3_0()); } 4586 { before(grammarAccess.getPartialModelDeclarationAccess().getModelsKeyword_0()); }
4587 ',' 4587 'models'
4588 { after(grammarAccess.getAllPatternEntryAccess().getCommaKeyword_2_3_0()); } 4588 { after(grammarAccess.getPartialModelDeclarationAccess().getModelsKeyword_0()); }
4589) 4589)
4590; 4590;
4591finally { 4591finally {
4592 restoreStackSize(stackSize); 4592 restoreStackSize(stackSize);
4593} 4593}
4594 4594
4595rule__AllPatternEntry__Group_2_3__1 4595rule__PartialModelDeclaration__Group__1
4596 @init { 4596 @init {
4597 int stackSize = keepStackSize(); 4597 int stackSize = keepStackSize();
4598 } 4598 }
4599: 4599:
4600 rule__AllPatternEntry__Group_2_3__1__Impl 4600 rule__PartialModelDeclaration__Group__1__Impl
4601; 4601 rule__PartialModelDeclaration__Group__2
4602finally { 4602;
4603 restoreStackSize(stackSize); 4603finally {
4604} 4604 restoreStackSize(stackSize);
4605 4605}
4606rule__AllPatternEntry__Group_2_3__1__Impl 4606
4607 @init { 4607rule__PartialModelDeclaration__Group__1__Impl
4608 int stackSize = keepStackSize(); 4608 @init {
4609 } 4609 int stackSize = keepStackSize();
4610: 4610 }
4611( 4611:
4612 { before(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_3_1()); } 4612(
4613 (rule__AllPatternEntry__ExclusuionAssignment_2_3_1) 4613 { before(grammarAccess.getPartialModelDeclarationAccess().getNameAssignment_1()); }
4614 { after(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_3_1()); } 4614 (rule__PartialModelDeclaration__NameAssignment_1)
4615) 4615 { after(grammarAccess.getPartialModelDeclarationAccess().getNameAssignment_1()); }
4616; 4616)
4617finally { 4617;
4618 restoreStackSize(stackSize); 4618finally {
4619} 4619 restoreStackSize(stackSize);
4620 4620}
4621 4621
4622rule__PatternElement__Group__0 4622rule__PartialModelDeclaration__Group__2
4623 @init { 4623 @init {
4624 int stackSize = keepStackSize(); 4624 int stackSize = keepStackSize();
4625 } 4625 }
4626: 4626:
4627 rule__PatternElement__Group__0__Impl 4627 rule__PartialModelDeclaration__Group__2__Impl
4628 rule__PatternElement__Group__1 4628;
4629; 4629finally {
4630finally { 4630 restoreStackSize(stackSize);
4631 restoreStackSize(stackSize); 4631}
4632} 4632
4633 4633rule__PartialModelDeclaration__Group__2__Impl
4634rule__PatternElement__Group__0__Impl 4634 @init {
4635 @init { 4635 int stackSize = keepStackSize();
4636 int stackSize = keepStackSize(); 4636 }
4637 } 4637:
4638: 4638(
4639( 4639 { before(grammarAccess.getPartialModelDeclarationAccess().getSpecificationAssignment_2()); }
4640 { before(grammarAccess.getPatternElementAccess().getGroup_0()); } 4640 (rule__PartialModelDeclaration__SpecificationAssignment_2)
4641 (rule__PatternElement__Group_0__0)? 4641 { after(grammarAccess.getPartialModelDeclarationAccess().getSpecificationAssignment_2()); }
4642 { after(grammarAccess.getPatternElementAccess().getGroup_0()); } 4642)
4643) 4643;
4644; 4644finally {
4645finally { 4645 restoreStackSize(stackSize);
4646 restoreStackSize(stackSize); 4646}
4647} 4647
4648 4648
4649rule__PatternElement__Group__1 4649rule__PatternSpecification__Group__0
4650 @init { 4650 @init {
4651 int stackSize = keepStackSize(); 4651 int stackSize = keepStackSize();
4652 } 4652 }
4653: 4653:
4654 rule__PatternElement__Group__1__Impl 4654 rule__PatternSpecification__Group__0__Impl
4655; 4655 rule__PatternSpecification__Group__1
4656finally { 4656;
4657 restoreStackSize(stackSize); 4657finally {
4658} 4658 restoreStackSize(stackSize);
4659 4659}
4660rule__PatternElement__Group__1__Impl 4660
4661 @init { 4661rule__PatternSpecification__Group__0__Impl
4662 int stackSize = keepStackSize(); 4662 @init {
4663 } 4663 int stackSize = keepStackSize();
4664: 4664 }
4665( 4665:
4666 { before(grammarAccess.getPatternElementAccess().getPatternAssignment_1()); } 4666(
4667 (rule__PatternElement__PatternAssignment_1) 4667 { before(grammarAccess.getPatternSpecificationAccess().getLeftCurlyBracketKeyword_0()); }
4668 { after(grammarAccess.getPatternElementAccess().getPatternAssignment_1()); } 4668 '{'
4669) 4669 { after(grammarAccess.getPatternSpecificationAccess().getLeftCurlyBracketKeyword_0()); }
4670; 4670)
4671finally { 4671;
4672 restoreStackSize(stackSize); 4672finally {
4673} 4673 restoreStackSize(stackSize);
4674 4674}
4675 4675
4676rule__PatternElement__Group_0__0 4676rule__PatternSpecification__Group__1
4677 @init { 4677 @init {
4678 int stackSize = keepStackSize(); 4678 int stackSize = keepStackSize();
4679 } 4679 }
4680: 4680:
4681 rule__PatternElement__Group_0__0__Impl 4681 rule__PatternSpecification__Group__1__Impl
4682 rule__PatternElement__Group_0__1 4682 rule__PatternSpecification__Group__2
4683; 4683;
4684finally { 4684finally {
4685 restoreStackSize(stackSize); 4685 restoreStackSize(stackSize);
4686} 4686}
4687 4687
4688rule__PatternElement__Group_0__0__Impl 4688rule__PatternSpecification__Group__1__Impl
4689 @init { 4689 @init {
4690 int stackSize = keepStackSize(); 4690 int stackSize = keepStackSize();
4691 } 4691 }
4692: 4692:
4693( 4693(
4694 { before(grammarAccess.getPatternElementAccess().getPackageAssignment_0_0()); } 4694 { before(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_1()); }
4695 (rule__PatternElement__PackageAssignment_0_0) 4695 (rule__PatternSpecification__EntriesAssignment_1)
4696 { after(grammarAccess.getPatternElementAccess().getPackageAssignment_0_0()); } 4696 { after(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_1()); }
4697) 4697)
4698; 4698;
4699finally { 4699finally {
4700 restoreStackSize(stackSize); 4700 restoreStackSize(stackSize);
4701} 4701}
4702 4702
4703rule__PatternElement__Group_0__1 4703rule__PatternSpecification__Group__2
4704 @init { 4704 @init {
4705 int stackSize = keepStackSize(); 4705 int stackSize = keepStackSize();
4706 } 4706 }
4707: 4707:
4708 rule__PatternElement__Group_0__1__Impl 4708 rule__PatternSpecification__Group__2__Impl
4709; 4709 rule__PatternSpecification__Group__3
4710finally { 4710;
4711 restoreStackSize(stackSize); 4711finally {
4712} 4712 restoreStackSize(stackSize);
4713 4713}
4714rule__PatternElement__Group_0__1__Impl 4714
4715 @init { 4715rule__PatternSpecification__Group__2__Impl
4716 int stackSize = keepStackSize(); 4716 @init {
4717 } 4717 int stackSize = keepStackSize();
4718: 4718 }
4719( 4719:
4720 { before(grammarAccess.getPatternElementAccess().getColonColonKeyword_0_1()); } 4720(
4721 '::' 4721 { before(grammarAccess.getPatternSpecificationAccess().getGroup_2()); }
4722 { after(grammarAccess.getPatternElementAccess().getColonColonKeyword_0_1()); } 4722 (rule__PatternSpecification__Group_2__0)*
4723) 4723 { after(grammarAccess.getPatternSpecificationAccess().getGroup_2()); }
4724; 4724)
4725finally { 4725;
4726 restoreStackSize(stackSize); 4726finally {
4727} 4727 restoreStackSize(stackSize);
4728 4728}
4729 4729
4730rule__GraphPatternDeclaration__Group__0 4730rule__PatternSpecification__Group__3
4731 @init { 4731 @init {
4732 int stackSize = keepStackSize(); 4732 int stackSize = keepStackSize();
4733 } 4733 }
4734: 4734:
4735 rule__GraphPatternDeclaration__Group__0__Impl 4735 rule__PatternSpecification__Group__3__Impl
4736 rule__GraphPatternDeclaration__Group__1 4736;
4737; 4737finally {
4738finally { 4738 restoreStackSize(stackSize);
4739 restoreStackSize(stackSize); 4739}
4740} 4740
4741 4741rule__PatternSpecification__Group__3__Impl
4742rule__GraphPatternDeclaration__Group__0__Impl 4742 @init {
4743 @init { 4743 int stackSize = keepStackSize();
4744 int stackSize = keepStackSize(); 4744 }
4745 } 4745:
4746: 4746(
4747( 4747 { before(grammarAccess.getPatternSpecificationAccess().getRightCurlyBracketKeyword_3()); }
4748 { before(grammarAccess.getGraphPatternDeclarationAccess().getConstraintsKeyword_0()); } 4748 '}'
4749 'constraints' 4749 { after(grammarAccess.getPatternSpecificationAccess().getRightCurlyBracketKeyword_3()); }
4750 { after(grammarAccess.getGraphPatternDeclarationAccess().getConstraintsKeyword_0()); } 4750)
4751) 4751;
4752; 4752finally {
4753finally { 4753 restoreStackSize(stackSize);
4754 restoreStackSize(stackSize); 4754}
4755} 4755
4756 4756
4757rule__GraphPatternDeclaration__Group__1 4757rule__PatternSpecification__Group_2__0
4758 @init { 4758 @init {
4759 int stackSize = keepStackSize(); 4759 int stackSize = keepStackSize();
4760 } 4760 }
4761: 4761:
4762 rule__GraphPatternDeclaration__Group__1__Impl 4762 rule__PatternSpecification__Group_2__0__Impl
4763 rule__GraphPatternDeclaration__Group__2 4763 rule__PatternSpecification__Group_2__1
4764; 4764;
4765finally { 4765finally {
4766 restoreStackSize(stackSize); 4766 restoreStackSize(stackSize);
4767} 4767}
4768 4768
4769rule__GraphPatternDeclaration__Group__1__Impl 4769rule__PatternSpecification__Group_2__0__Impl
4770 @init { 4770 @init {
4771 int stackSize = keepStackSize(); 4771 int stackSize = keepStackSize();
4772 } 4772 }
4773: 4773:
4774( 4774(
4775 { before(grammarAccess.getGraphPatternDeclarationAccess().getNameAssignment_1()); } 4775 { before(grammarAccess.getPatternSpecificationAccess().getCommaKeyword_2_0()); }
4776 (rule__GraphPatternDeclaration__NameAssignment_1) 4776 ','
4777 { after(grammarAccess.getGraphPatternDeclarationAccess().getNameAssignment_1()); } 4777 { after(grammarAccess.getPatternSpecificationAccess().getCommaKeyword_2_0()); }
4778) 4778)
4779; 4779;
4780finally { 4780finally {
4781 restoreStackSize(stackSize); 4781 restoreStackSize(stackSize);
4782} 4782}
4783 4783
4784rule__GraphPatternDeclaration__Group__2 4784rule__PatternSpecification__Group_2__1
4785 @init { 4785 @init {
4786 int stackSize = keepStackSize(); 4786 int stackSize = keepStackSize();
4787 } 4787 }
4788: 4788:
4789 rule__GraphPatternDeclaration__Group__2__Impl 4789 rule__PatternSpecification__Group_2__1__Impl
4790; 4790;
4791finally { 4791finally {
4792 restoreStackSize(stackSize); 4792 restoreStackSize(stackSize);
4793} 4793}
4794 4794
4795rule__GraphPatternDeclaration__Group__2__Impl 4795rule__PatternSpecification__Group_2__1__Impl
4796 @init { 4796 @init {
4797 int stackSize = keepStackSize(); 4797 int stackSize = keepStackSize();
4798 } 4798 }
4799: 4799:
4800( 4800(
4801 { before(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationAssignment_2()); } 4801 { before(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_2_1()); }
4802 (rule__GraphPatternDeclaration__SpecificationAssignment_2) 4802 (rule__PatternSpecification__EntriesAssignment_2_1)
4803 { after(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationAssignment_2()); } 4803 { after(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_2_1()); }
4804) 4804)
4805; 4805;
4806finally { 4806finally {
4807 restoreStackSize(stackSize); 4807 restoreStackSize(stackSize);
4808} 4808}
4809 4809
4810 4810
4811rule__ConfigSpecification__Group__0 4811rule__AllPatternEntry__Group__0
4812 @init { 4812 @init {
4813 int stackSize = keepStackSize(); 4813 int stackSize = keepStackSize();
4814 } 4814 }
4815: 4815:
4816 rule__ConfigSpecification__Group__0__Impl 4816 rule__AllPatternEntry__Group__0__Impl
4817 rule__ConfigSpecification__Group__1 4817 rule__AllPatternEntry__Group__1
4818; 4818;
4819finally { 4819finally {
4820 restoreStackSize(stackSize); 4820 restoreStackSize(stackSize);
4821} 4821}
4822 4822
4823rule__ConfigSpecification__Group__0__Impl 4823rule__AllPatternEntry__Group__0__Impl
4824 @init { 4824 @init {
4825 int stackSize = keepStackSize(); 4825 int stackSize = keepStackSize();
4826 } 4826 }
4827: 4827:
4828( 4828(
4829 { before(grammarAccess.getConfigSpecificationAccess().getConfigSpecificationAction_0()); } 4829 { before(grammarAccess.getAllPatternEntryAccess().getPackageKeyword_0()); }
4830 () 4830 'package'
4831 { after(grammarAccess.getConfigSpecificationAccess().getConfigSpecificationAction_0()); } 4831 { after(grammarAccess.getAllPatternEntryAccess().getPackageKeyword_0()); }
4832) 4832)
4833; 4833;
4834finally { 4834finally {
4835 restoreStackSize(stackSize); 4835 restoreStackSize(stackSize);
4836} 4836}
4837 4837
4838rule__ConfigSpecification__Group__1 4838rule__AllPatternEntry__Group__1
4839 @init { 4839 @init {
4840 int stackSize = keepStackSize(); 4840 int stackSize = keepStackSize();
4841 } 4841 }
4842: 4842:
4843 rule__ConfigSpecification__Group__1__Impl 4843 rule__AllPatternEntry__Group__1__Impl
4844 rule__ConfigSpecification__Group__2 4844 rule__AllPatternEntry__Group__2
4845; 4845;
4846finally { 4846finally {
4847 restoreStackSize(stackSize); 4847 restoreStackSize(stackSize);
4848} 4848}
4849 4849
4850rule__ConfigSpecification__Group__1__Impl 4850rule__AllPatternEntry__Group__1__Impl
4851 @init { 4851 @init {
4852 int stackSize = keepStackSize(); 4852 int stackSize = keepStackSize();
4853 } 4853 }
4854: 4854:
4855( 4855(
4856 { before(grammarAccess.getConfigSpecificationAccess().getLeftCurlyBracketKeyword_1()); } 4856 { before(grammarAccess.getAllPatternEntryAccess().getPackageAssignment_1()); }
4857 '{' 4857 (rule__AllPatternEntry__PackageAssignment_1)
4858 { after(grammarAccess.getConfigSpecificationAccess().getLeftCurlyBracketKeyword_1()); } 4858 { after(grammarAccess.getAllPatternEntryAccess().getPackageAssignment_1()); }
4859) 4859)
4860; 4860;
4861finally { 4861finally {
4862 restoreStackSize(stackSize); 4862 restoreStackSize(stackSize);
4863} 4863}
4864 4864
4865rule__ConfigSpecification__Group__2 4865rule__AllPatternEntry__Group__2
4866 @init { 4866 @init {
4867 int stackSize = keepStackSize(); 4867 int stackSize = keepStackSize();
4868 } 4868 }
4869: 4869:
4870 rule__ConfigSpecification__Group__2__Impl 4870 rule__AllPatternEntry__Group__2__Impl
4871 rule__ConfigSpecification__Group__3 4871;
4872; 4872finally {
4873finally { 4873 restoreStackSize(stackSize);
4874 restoreStackSize(stackSize); 4874}
4875} 4875
4876 4876rule__AllPatternEntry__Group__2__Impl
4877rule__ConfigSpecification__Group__2__Impl 4877 @init {
4878 @init { 4878 int stackSize = keepStackSize();
4879 int stackSize = keepStackSize(); 4879 }
4880 } 4880:
4881: 4881(
4882( 4882 { before(grammarAccess.getAllPatternEntryAccess().getGroup_2()); }
4883 { before(grammarAccess.getConfigSpecificationAccess().getGroup_2()); } 4883 (rule__AllPatternEntry__Group_2__0)?
4884 (rule__ConfigSpecification__Group_2__0)? 4884 { after(grammarAccess.getAllPatternEntryAccess().getGroup_2()); }
4885 { after(grammarAccess.getConfigSpecificationAccess().getGroup_2()); } 4885)
4886) 4886;
4887; 4887finally {
4888finally { 4888 restoreStackSize(stackSize);
4889 restoreStackSize(stackSize); 4889}
4890} 4890
4891 4891
4892rule__ConfigSpecification__Group__3 4892rule__AllPatternEntry__Group_2__0
4893 @init { 4893 @init {
4894 int stackSize = keepStackSize(); 4894 int stackSize = keepStackSize();
4895 } 4895 }
4896: 4896:
4897 rule__ConfigSpecification__Group__3__Impl 4897 rule__AllPatternEntry__Group_2__0__Impl
4898; 4898 rule__AllPatternEntry__Group_2__1
4899finally { 4899;
4900 restoreStackSize(stackSize); 4900finally {
4901} 4901 restoreStackSize(stackSize);
4902 4902}
4903rule__ConfigSpecification__Group__3__Impl 4903
4904 @init { 4904rule__AllPatternEntry__Group_2__0__Impl
4905 int stackSize = keepStackSize(); 4905 @init {
4906 } 4906 int stackSize = keepStackSize();
4907: 4907 }
4908( 4908:
4909 { before(grammarAccess.getConfigSpecificationAccess().getRightCurlyBracketKeyword_3()); } 4909(
4910 '}' 4910 { before(grammarAccess.getAllPatternEntryAccess().getExcludingKeyword_2_0()); }
4911 { after(grammarAccess.getConfigSpecificationAccess().getRightCurlyBracketKeyword_3()); } 4911 'excluding'
4912) 4912 { after(grammarAccess.getAllPatternEntryAccess().getExcludingKeyword_2_0()); }
4913; 4913)
4914finally { 4914;
4915 restoreStackSize(stackSize); 4915finally {
4916} 4916 restoreStackSize(stackSize);
4917 4917}
4918 4918
4919rule__ConfigSpecification__Group_2__0 4919rule__AllPatternEntry__Group_2__1
4920 @init { 4920 @init {
4921 int stackSize = keepStackSize(); 4921 int stackSize = keepStackSize();
4922 } 4922 }
4923: 4923:
4924 rule__ConfigSpecification__Group_2__0__Impl 4924 rule__AllPatternEntry__Group_2__1__Impl
4925 rule__ConfigSpecification__Group_2__1 4925 rule__AllPatternEntry__Group_2__2
4926; 4926;
4927finally { 4927finally {
4928 restoreStackSize(stackSize); 4928 restoreStackSize(stackSize);
4929} 4929}
4930 4930
4931rule__ConfigSpecification__Group_2__0__Impl 4931rule__AllPatternEntry__Group_2__1__Impl
4932 @init { 4932 @init {
4933 int stackSize = keepStackSize(); 4933 int stackSize = keepStackSize();
4934 } 4934 }
4935: 4935:
4936( 4936(
4937 { before(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_0()); } 4937 { before(grammarAccess.getAllPatternEntryAccess().getLeftCurlyBracketKeyword_2_1()); }
4938 (rule__ConfigSpecification__EntriesAssignment_2_0) 4938 '{'
4939 { after(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_0()); } 4939 { after(grammarAccess.getAllPatternEntryAccess().getLeftCurlyBracketKeyword_2_1()); }
4940) 4940)
4941; 4941;
4942finally { 4942finally {
4943 restoreStackSize(stackSize); 4943 restoreStackSize(stackSize);
4944} 4944}
4945 4945
4946rule__ConfigSpecification__Group_2__1 4946rule__AllPatternEntry__Group_2__2
4947 @init { 4947 @init {
4948 int stackSize = keepStackSize(); 4948 int stackSize = keepStackSize();
4949 } 4949 }
4950: 4950:
4951 rule__ConfigSpecification__Group_2__1__Impl 4951 rule__AllPatternEntry__Group_2__2__Impl
4952; 4952 rule__AllPatternEntry__Group_2__3
4953finally { 4953;
4954 restoreStackSize(stackSize); 4954finally {
4955} 4955 restoreStackSize(stackSize);
4956 4956}
4957rule__ConfigSpecification__Group_2__1__Impl 4957
4958 @init { 4958rule__AllPatternEntry__Group_2__2__Impl
4959 int stackSize = keepStackSize(); 4959 @init {
4960 } 4960 int stackSize = keepStackSize();
4961: 4961 }
4962( 4962:
4963 { before(grammarAccess.getConfigSpecificationAccess().getGroup_2_1()); } 4963(
4964 (rule__ConfigSpecification__Group_2_1__0)* 4964 { before(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_2()); }
4965 { after(grammarAccess.getConfigSpecificationAccess().getGroup_2_1()); } 4965 (rule__AllPatternEntry__ExclusuionAssignment_2_2)
4966) 4966 { after(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_2()); }
4967; 4967)
4968finally { 4968;
4969 restoreStackSize(stackSize); 4969finally {
4970} 4970 restoreStackSize(stackSize);
4971 4971}
4972 4972
4973rule__ConfigSpecification__Group_2_1__0 4973rule__AllPatternEntry__Group_2__3
4974 @init { 4974 @init {
4975 int stackSize = keepStackSize(); 4975 int stackSize = keepStackSize();
4976 } 4976 }
4977: 4977:
4978 rule__ConfigSpecification__Group_2_1__0__Impl 4978 rule__AllPatternEntry__Group_2__3__Impl
4979 rule__ConfigSpecification__Group_2_1__1 4979 rule__AllPatternEntry__Group_2__4
4980; 4980;
4981finally { 4981finally {
4982 restoreStackSize(stackSize); 4982 restoreStackSize(stackSize);
4983} 4983}
4984 4984
4985rule__ConfigSpecification__Group_2_1__0__Impl 4985rule__AllPatternEntry__Group_2__3__Impl
4986 @init { 4986 @init {
4987 int stackSize = keepStackSize(); 4987 int stackSize = keepStackSize();
4988 } 4988 }
4989: 4989:
4990( 4990(
4991 { before(grammarAccess.getConfigSpecificationAccess().getCommaKeyword_2_1_0()); } 4991 { before(grammarAccess.getAllPatternEntryAccess().getGroup_2_3()); }
4992 ',' 4992 (rule__AllPatternEntry__Group_2_3__0)*
4993 { after(grammarAccess.getConfigSpecificationAccess().getCommaKeyword_2_1_0()); } 4993 { after(grammarAccess.getAllPatternEntryAccess().getGroup_2_3()); }
4994) 4994)
4995; 4995;
4996finally { 4996finally {
4997 restoreStackSize(stackSize); 4997 restoreStackSize(stackSize);
4998} 4998}
4999 4999
5000rule__ConfigSpecification__Group_2_1__1 5000rule__AllPatternEntry__Group_2__4
5001 @init { 5001 @init {
5002 int stackSize = keepStackSize(); 5002 int stackSize = keepStackSize();
5003 } 5003 }
5004: 5004:
5005 rule__ConfigSpecification__Group_2_1__1__Impl 5005 rule__AllPatternEntry__Group_2__4__Impl
5006; 5006;
5007finally { 5007finally {
5008 restoreStackSize(stackSize); 5008 restoreStackSize(stackSize);
5009} 5009}
5010 5010
5011rule__ConfigSpecification__Group_2_1__1__Impl 5011rule__AllPatternEntry__Group_2__4__Impl
5012 @init { 5012 @init {
5013 int stackSize = keepStackSize(); 5013 int stackSize = keepStackSize();
5014 } 5014 }
5015: 5015:
5016( 5016(
5017 { before(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_1_1()); } 5017 { before(grammarAccess.getAllPatternEntryAccess().getRightCurlyBracketKeyword_2_4()); }
5018 (rule__ConfigSpecification__EntriesAssignment_2_1_1) 5018 '}'
5019 { after(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_1_1()); } 5019 { after(grammarAccess.getAllPatternEntryAccess().getRightCurlyBracketKeyword_2_4()); }
5020) 5020)
5021; 5021;
5022finally { 5022finally {
5023 restoreStackSize(stackSize); 5023 restoreStackSize(stackSize);
5024} 5024}
5025 5025
5026 5026
5027rule__ConfigDeclaration__Group__0 5027rule__AllPatternEntry__Group_2_3__0
5028 @init { 5028 @init {
5029 int stackSize = keepStackSize(); 5029 int stackSize = keepStackSize();
5030 } 5030 }
5031: 5031:
5032 rule__ConfigDeclaration__Group__0__Impl 5032 rule__AllPatternEntry__Group_2_3__0__Impl
5033 rule__ConfigDeclaration__Group__1 5033 rule__AllPatternEntry__Group_2_3__1
5034; 5034;
5035finally { 5035finally {
5036 restoreStackSize(stackSize); 5036 restoreStackSize(stackSize);
5037} 5037}
5038 5038
5039rule__ConfigDeclaration__Group__0__Impl 5039rule__AllPatternEntry__Group_2_3__0__Impl
5040 @init { 5040 @init {
5041 int stackSize = keepStackSize(); 5041 int stackSize = keepStackSize();
5042 } 5042 }
5043: 5043:
5044( 5044(
5045 { before(grammarAccess.getConfigDeclarationAccess().getConfigKeyword_0()); } 5045 { before(grammarAccess.getAllPatternEntryAccess().getCommaKeyword_2_3_0()); }
5046 'config' 5046 ','
5047 { after(grammarAccess.getConfigDeclarationAccess().getConfigKeyword_0()); } 5047 { after(grammarAccess.getAllPatternEntryAccess().getCommaKeyword_2_3_0()); }
5048) 5048)
5049; 5049;
5050finally { 5050finally {
5051 restoreStackSize(stackSize); 5051 restoreStackSize(stackSize);
5052} 5052}
5053 5053
5054rule__ConfigDeclaration__Group__1 5054rule__AllPatternEntry__Group_2_3__1
5055 @init { 5055 @init {
5056 int stackSize = keepStackSize(); 5056 int stackSize = keepStackSize();
5057 } 5057 }
5058: 5058:
5059 rule__ConfigDeclaration__Group__1__Impl 5059 rule__AllPatternEntry__Group_2_3__1__Impl
5060 rule__ConfigDeclaration__Group__2 5060;
5061; 5061finally {
5062finally { 5062 restoreStackSize(stackSize);
5063 restoreStackSize(stackSize); 5063}
5064} 5064
5065 5065rule__AllPatternEntry__Group_2_3__1__Impl
5066rule__ConfigDeclaration__Group__1__Impl 5066 @init {
5067 @init { 5067 int stackSize = keepStackSize();
5068 int stackSize = keepStackSize(); 5068 }
5069 } 5069:
5070: 5070(
5071( 5071 { before(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_3_1()); }
5072 { before(grammarAccess.getConfigDeclarationAccess().getNameAssignment_1()); } 5072 (rule__AllPatternEntry__ExclusuionAssignment_2_3_1)
5073 (rule__ConfigDeclaration__NameAssignment_1) 5073 { after(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_3_1()); }
5074 { after(grammarAccess.getConfigDeclarationAccess().getNameAssignment_1()); } 5074)
5075) 5075;
5076; 5076finally {
5077finally { 5077 restoreStackSize(stackSize);
5078 restoreStackSize(stackSize); 5078}
5079} 5079
5080 5080
5081rule__ConfigDeclaration__Group__2 5081rule__PatternElement__Group__0
5082 @init { 5082 @init {
5083 int stackSize = keepStackSize(); 5083 int stackSize = keepStackSize();
5084 } 5084 }
5085: 5085:
5086 rule__ConfigDeclaration__Group__2__Impl 5086 rule__PatternElement__Group__0__Impl
5087; 5087 rule__PatternElement__Group__1
5088finally { 5088;
5089 restoreStackSize(stackSize); 5089finally {
5090} 5090 restoreStackSize(stackSize);
5091 5091}
5092rule__ConfigDeclaration__Group__2__Impl 5092
5093 @init { 5093rule__PatternElement__Group__0__Impl
5094 int stackSize = keepStackSize(); 5094 @init {
5095 } 5095 int stackSize = keepStackSize();
5096: 5096 }
5097( 5097:
5098 { before(grammarAccess.getConfigDeclarationAccess().getSpecificationAssignment_2()); } 5098(
5099 (rule__ConfigDeclaration__SpecificationAssignment_2) 5099 { before(grammarAccess.getPatternElementAccess().getGroup_0()); }
5100 { after(grammarAccess.getConfigDeclarationAccess().getSpecificationAssignment_2()); } 5100 (rule__PatternElement__Group_0__0)?
5101) 5101 { after(grammarAccess.getPatternElementAccess().getGroup_0()); }
5102; 5102)
5103finally { 5103;
5104 restoreStackSize(stackSize); 5104finally {
5105} 5105 restoreStackSize(stackSize);
5106 5106}
5107 5107
5108rule__DocumentationEntry__Group__0 5108rule__PatternElement__Group__1
5109 @init { 5109 @init {
5110 int stackSize = keepStackSize(); 5110 int stackSize = keepStackSize();
5111 } 5111 }
5112: 5112:
5113 rule__DocumentationEntry__Group__0__Impl 5113 rule__PatternElement__Group__1__Impl
5114 rule__DocumentationEntry__Group__1 5114;
5115; 5115finally {
5116finally { 5116 restoreStackSize(stackSize);
5117 restoreStackSize(stackSize); 5117}
5118} 5118
5119 5119rule__PatternElement__Group__1__Impl
5120rule__DocumentationEntry__Group__0__Impl 5120 @init {
5121 @init { 5121 int stackSize = keepStackSize();
5122 int stackSize = keepStackSize(); 5122 }
5123 } 5123:
5124: 5124(
5125( 5125 { before(grammarAccess.getPatternElementAccess().getPatternAssignment_1()); }
5126 { before(grammarAccess.getDocumentationEntryAccess().getLogLevelKeyword_0()); } 5126 (rule__PatternElement__PatternAssignment_1)
5127 'log-level' 5127 { after(grammarAccess.getPatternElementAccess().getPatternAssignment_1()); }
5128 { after(grammarAccess.getDocumentationEntryAccess().getLogLevelKeyword_0()); } 5128)
5129) 5129;
5130; 5130finally {
5131finally { 5131 restoreStackSize(stackSize);
5132 restoreStackSize(stackSize); 5132}
5133} 5133
5134 5134
5135rule__DocumentationEntry__Group__1 5135rule__PatternElement__Group_0__0
5136 @init { 5136 @init {
5137 int stackSize = keepStackSize(); 5137 int stackSize = keepStackSize();
5138 } 5138 }
5139: 5139:
5140 rule__DocumentationEntry__Group__1__Impl 5140 rule__PatternElement__Group_0__0__Impl
5141 rule__DocumentationEntry__Group__2 5141 rule__PatternElement__Group_0__1
5142; 5142;
5143finally { 5143finally {
5144 restoreStackSize(stackSize); 5144 restoreStackSize(stackSize);
5145} 5145}
5146 5146
5147rule__DocumentationEntry__Group__1__Impl 5147rule__PatternElement__Group_0__0__Impl
5148 @init { 5148 @init {
5149 int stackSize = keepStackSize(); 5149 int stackSize = keepStackSize();
5150 } 5150 }
5151: 5151:
5152( 5152(
5153 { before(grammarAccess.getDocumentationEntryAccess().getEqualsSignKeyword_1()); } 5153 { before(grammarAccess.getPatternElementAccess().getPackageAssignment_0_0()); }
5154 '=' 5154 (rule__PatternElement__PackageAssignment_0_0)
5155 { after(grammarAccess.getDocumentationEntryAccess().getEqualsSignKeyword_1()); } 5155 { after(grammarAccess.getPatternElementAccess().getPackageAssignment_0_0()); }
5156) 5156)
5157; 5157;
5158finally { 5158finally {
5159 restoreStackSize(stackSize); 5159 restoreStackSize(stackSize);
5160} 5160}
5161 5161
5162rule__DocumentationEntry__Group__2 5162rule__PatternElement__Group_0__1
5163 @init { 5163 @init {
5164 int stackSize = keepStackSize(); 5164 int stackSize = keepStackSize();
5165 } 5165 }
5166: 5166:
5167 rule__DocumentationEntry__Group__2__Impl 5167 rule__PatternElement__Group_0__1__Impl
5168; 5168;
5169finally { 5169finally {
5170 restoreStackSize(stackSize); 5170 restoreStackSize(stackSize);
5171} 5171}
5172 5172
5173rule__DocumentationEntry__Group__2__Impl 5173rule__PatternElement__Group_0__1__Impl
5174 @init { 5174 @init {
5175 int stackSize = keepStackSize(); 5175 int stackSize = keepStackSize();
5176 } 5176 }
5177: 5177:
5178( 5178(
5179 { before(grammarAccess.getDocumentationEntryAccess().getLevelAssignment_2()); } 5179 { before(grammarAccess.getPatternElementAccess().getColonColonKeyword_0_1()); }
5180 (rule__DocumentationEntry__LevelAssignment_2) 5180 '::'
5181 { after(grammarAccess.getDocumentationEntryAccess().getLevelAssignment_2()); } 5181 { after(grammarAccess.getPatternElementAccess().getColonColonKeyword_0_1()); }
5182) 5182)
5183; 5183;
5184finally { 5184finally {
5185 restoreStackSize(stackSize); 5185 restoreStackSize(stackSize);
5186} 5186}
5187 5187
5188 5188
5189rule__RuntimeEntry__Group__0 5189rule__GraphPatternDeclaration__Group__0
5190 @init { 5190 @init {
5191 int stackSize = keepStackSize(); 5191 int stackSize = keepStackSize();
5192 } 5192 }
5193: 5193:
5194 rule__RuntimeEntry__Group__0__Impl 5194 rule__GraphPatternDeclaration__Group__0__Impl
5195 rule__RuntimeEntry__Group__1 5195 rule__GraphPatternDeclaration__Group__1
5196; 5196;
5197finally { 5197finally {
5198 restoreStackSize(stackSize); 5198 restoreStackSize(stackSize);
5199} 5199}
5200 5200
5201rule__RuntimeEntry__Group__0__Impl 5201rule__GraphPatternDeclaration__Group__0__Impl
5202 @init { 5202 @init {
5203 int stackSize = keepStackSize(); 5203 int stackSize = keepStackSize();
5204 } 5204 }
5205: 5205:
5206( 5206(
5207 { before(grammarAccess.getRuntimeEntryAccess().getRuntimeKeyword_0()); } 5207 { before(grammarAccess.getGraphPatternDeclarationAccess().getConstraintsKeyword_0()); }
5208 'runtime' 5208 'constraints'
5209 { after(grammarAccess.getRuntimeEntryAccess().getRuntimeKeyword_0()); } 5209 { after(grammarAccess.getGraphPatternDeclarationAccess().getConstraintsKeyword_0()); }
5210) 5210)
5211; 5211;
5212finally { 5212finally {
5213 restoreStackSize(stackSize); 5213 restoreStackSize(stackSize);
5214} 5214}
5215 5215
5216rule__RuntimeEntry__Group__1 5216rule__GraphPatternDeclaration__Group__1
5217 @init { 5217 @init {
5218 int stackSize = keepStackSize(); 5218 int stackSize = keepStackSize();
5219 } 5219 }
5220: 5220:
5221 rule__RuntimeEntry__Group__1__Impl 5221 rule__GraphPatternDeclaration__Group__1__Impl
5222 rule__RuntimeEntry__Group__2 5222 rule__GraphPatternDeclaration__Group__2
5223; 5223;
5224finally { 5224finally {
5225 restoreStackSize(stackSize); 5225 restoreStackSize(stackSize);
5226} 5226}
5227 5227
5228rule__RuntimeEntry__Group__1__Impl 5228rule__GraphPatternDeclaration__Group__1__Impl
5229 @init { 5229 @init {
5230 int stackSize = keepStackSize(); 5230 int stackSize = keepStackSize();
5231 } 5231 }
5232: 5232:
5233( 5233(
5234 { before(grammarAccess.getRuntimeEntryAccess().getEqualsSignKeyword_1()); } 5234 { before(grammarAccess.getGraphPatternDeclarationAccess().getNameAssignment_1()); }
5235 '=' 5235 (rule__GraphPatternDeclaration__NameAssignment_1)
5236 { after(grammarAccess.getRuntimeEntryAccess().getEqualsSignKeyword_1()); } 5236 { after(grammarAccess.getGraphPatternDeclarationAccess().getNameAssignment_1()); }
5237) 5237)
5238; 5238;
5239finally { 5239finally {
5240 restoreStackSize(stackSize); 5240 restoreStackSize(stackSize);
5241} 5241}
5242 5242
5243rule__RuntimeEntry__Group__2 5243rule__GraphPatternDeclaration__Group__2
5244 @init { 5244 @init {
5245 int stackSize = keepStackSize(); 5245 int stackSize = keepStackSize();
5246 } 5246 }
5247: 5247:
5248 rule__RuntimeEntry__Group__2__Impl 5248 rule__GraphPatternDeclaration__Group__2__Impl
5249; 5249;
5250finally { 5250finally {
5251 restoreStackSize(stackSize); 5251 restoreStackSize(stackSize);
5252} 5252}
5253 5253
5254rule__RuntimeEntry__Group__2__Impl 5254rule__GraphPatternDeclaration__Group__2__Impl
5255 @init { 5255 @init {
5256 int stackSize = keepStackSize(); 5256 int stackSize = keepStackSize();
5257 } 5257 }
5258: 5258:
5259( 5259(
5260 { before(grammarAccess.getRuntimeEntryAccess().getMillisecLimitAssignment_2()); } 5260 { before(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationAssignment_2()); }
5261 (rule__RuntimeEntry__MillisecLimitAssignment_2) 5261 (rule__GraphPatternDeclaration__SpecificationAssignment_2)
5262 { after(grammarAccess.getRuntimeEntryAccess().getMillisecLimitAssignment_2()); } 5262 { after(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationAssignment_2()); }
5263) 5263)
5264; 5264;
5265finally { 5265finally {
5266 restoreStackSize(stackSize); 5266 restoreStackSize(stackSize);
5267} 5267}
5268 5268
5269 5269
5270rule__MemoryEntry__Group__0 5270rule__ObjectiveSpecification__Group__0
5271 @init { 5271 @init {
5272 int stackSize = keepStackSize(); 5272 int stackSize = keepStackSize();
5273 } 5273 }
5274: 5274:
5275 rule__MemoryEntry__Group__0__Impl 5275 rule__ObjectiveSpecification__Group__0__Impl
5276 rule__MemoryEntry__Group__1 5276 rule__ObjectiveSpecification__Group__1
5277; 5277;
5278finally { 5278finally {
5279 restoreStackSize(stackSize); 5279 restoreStackSize(stackSize);
5280} 5280}
5281 5281
5282rule__MemoryEntry__Group__0__Impl 5282rule__ObjectiveSpecification__Group__0__Impl
5283 @init { 5283 @init {
5284 int stackSize = keepStackSize(); 5284 int stackSize = keepStackSize();
5285 } 5285 }
5286: 5286:
5287( 5287(
5288 { before(grammarAccess.getMemoryEntryAccess().getMemoryKeyword_0()); } 5288 { before(grammarAccess.getObjectiveSpecificationAccess().getLeftCurlyBracketKeyword_0()); }
5289 'memory' 5289 '{'
5290 { after(grammarAccess.getMemoryEntryAccess().getMemoryKeyword_0()); } 5290 { after(grammarAccess.getObjectiveSpecificationAccess().getLeftCurlyBracketKeyword_0()); }
5291) 5291)
5292; 5292;
5293finally { 5293finally {
5294 restoreStackSize(stackSize); 5294 restoreStackSize(stackSize);
5295} 5295}
5296 5296
5297rule__MemoryEntry__Group__1 5297rule__ObjectiveSpecification__Group__1
5298 @init { 5298 @init {
5299 int stackSize = keepStackSize(); 5299 int stackSize = keepStackSize();
5300 } 5300 }
5301: 5301:
5302 rule__MemoryEntry__Group__1__Impl 5302 rule__ObjectiveSpecification__Group__1__Impl
5303 rule__MemoryEntry__Group__2 5303 rule__ObjectiveSpecification__Group__2
5304; 5304;
5305finally { 5305finally {
5306 restoreStackSize(stackSize); 5306 restoreStackSize(stackSize);
5307} 5307}
5308 5308
5309rule__MemoryEntry__Group__1__Impl 5309rule__ObjectiveSpecification__Group__1__Impl
5310 @init { 5310 @init {
5311 int stackSize = keepStackSize(); 5311 int stackSize = keepStackSize();
5312 } 5312 }
5313: 5313:
5314( 5314(
5315 { before(grammarAccess.getMemoryEntryAccess().getEqualsSignKeyword_1()); } 5315 { before(grammarAccess.getObjectiveSpecificationAccess().getEntriesAssignment_1()); }
5316 '=' 5316 (rule__ObjectiveSpecification__EntriesAssignment_1)
5317 { after(grammarAccess.getMemoryEntryAccess().getEqualsSignKeyword_1()); } 5317 { after(grammarAccess.getObjectiveSpecificationAccess().getEntriesAssignment_1()); }
5318) 5318)
5319; 5319;
5320finally { 5320finally {
5321 restoreStackSize(stackSize); 5321 restoreStackSize(stackSize);
5322} 5322}
5323 5323
5324rule__MemoryEntry__Group__2 5324rule__ObjectiveSpecification__Group__2
5325 @init { 5325 @init {
5326 int stackSize = keepStackSize(); 5326 int stackSize = keepStackSize();
5327 } 5327 }
5328: 5328:
5329 rule__MemoryEntry__Group__2__Impl 5329 rule__ObjectiveSpecification__Group__2__Impl
5330; 5330 rule__ObjectiveSpecification__Group__3
5331finally { 5331;
5332 restoreStackSize(stackSize); 5332finally {
5333} 5333 restoreStackSize(stackSize);
5334 5334}
5335rule__MemoryEntry__Group__2__Impl 5335
5336 @init { 5336rule__ObjectiveSpecification__Group__2__Impl
5337 int stackSize = keepStackSize(); 5337 @init {
5338 } 5338 int stackSize = keepStackSize();
5339: 5339 }
5340( 5340:
5341 { before(grammarAccess.getMemoryEntryAccess().getMegabyteLimitAssignment_2()); } 5341(
5342 (rule__MemoryEntry__MegabyteLimitAssignment_2) 5342 { before(grammarAccess.getObjectiveSpecificationAccess().getGroup_2()); }
5343 { after(grammarAccess.getMemoryEntryAccess().getMegabyteLimitAssignment_2()); } 5343 (rule__ObjectiveSpecification__Group_2__0)*
5344) 5344 { after(grammarAccess.getObjectiveSpecificationAccess().getGroup_2()); }
5345; 5345)
5346finally { 5346;
5347 restoreStackSize(stackSize); 5347finally {
5348} 5348 restoreStackSize(stackSize);
5349 5349}
5350 5350
5351rule__CustomEntry__Group__0 5351rule__ObjectiveSpecification__Group__3
5352 @init { 5352 @init {
5353 int stackSize = keepStackSize(); 5353 int stackSize = keepStackSize();
5354 } 5354 }
5355: 5355:
5356 rule__CustomEntry__Group__0__Impl 5356 rule__ObjectiveSpecification__Group__3__Impl
5357 rule__CustomEntry__Group__1 5357;
5358; 5358finally {
5359finally { 5359 restoreStackSize(stackSize);
5360 restoreStackSize(stackSize); 5360}
5361} 5361
5362 5362rule__ObjectiveSpecification__Group__3__Impl
5363rule__CustomEntry__Group__0__Impl 5363 @init {
5364 @init { 5364 int stackSize = keepStackSize();
5365 int stackSize = keepStackSize(); 5365 }
5366 } 5366:
5367: 5367(
5368( 5368 { before(grammarAccess.getObjectiveSpecificationAccess().getRightCurlyBracketKeyword_3()); }
5369 { before(grammarAccess.getCustomEntryAccess().getKeyAssignment_0()); } 5369 '}'
5370 (rule__CustomEntry__KeyAssignment_0) 5370 { after(grammarAccess.getObjectiveSpecificationAccess().getRightCurlyBracketKeyword_3()); }
5371 { after(grammarAccess.getCustomEntryAccess().getKeyAssignment_0()); } 5371)
5372) 5372;
5373; 5373finally {
5374finally { 5374 restoreStackSize(stackSize);
5375 restoreStackSize(stackSize); 5375}
5376} 5376
5377 5377
5378rule__CustomEntry__Group__1 5378rule__ObjectiveSpecification__Group_2__0
5379 @init { 5379 @init {
5380 int stackSize = keepStackSize(); 5380 int stackSize = keepStackSize();
5381 } 5381 }
5382: 5382:
5383 rule__CustomEntry__Group__1__Impl 5383 rule__ObjectiveSpecification__Group_2__0__Impl
5384 rule__CustomEntry__Group__2 5384 rule__ObjectiveSpecification__Group_2__1
5385; 5385;
5386finally { 5386finally {
5387 restoreStackSize(stackSize); 5387 restoreStackSize(stackSize);
5388} 5388}
5389 5389
5390rule__CustomEntry__Group__1__Impl 5390rule__ObjectiveSpecification__Group_2__0__Impl
5391 @init { 5391 @init {
5392 int stackSize = keepStackSize(); 5392 int stackSize = keepStackSize();
5393 } 5393 }
5394: 5394:
5395( 5395(
5396 { before(grammarAccess.getCustomEntryAccess().getEqualsSignKeyword_1()); } 5396 { before(grammarAccess.getObjectiveSpecificationAccess().getCommaKeyword_2_0()); }
5397 '=' 5397 ','
5398 { after(grammarAccess.getCustomEntryAccess().getEqualsSignKeyword_1()); } 5398 { after(grammarAccess.getObjectiveSpecificationAccess().getCommaKeyword_2_0()); }
5399) 5399)
5400; 5400;
5401finally { 5401finally {
5402 restoreStackSize(stackSize); 5402 restoreStackSize(stackSize);
5403} 5403}
5404 5404
5405rule__CustomEntry__Group__2 5405rule__ObjectiveSpecification__Group_2__1
5406 @init { 5406 @init {
5407 int stackSize = keepStackSize(); 5407 int stackSize = keepStackSize();
5408 } 5408 }
5409: 5409:
5410 rule__CustomEntry__Group__2__Impl 5410 rule__ObjectiveSpecification__Group_2__1__Impl
5411; 5411;
5412finally { 5412finally {
5413 restoreStackSize(stackSize); 5413 restoreStackSize(stackSize);
5414} 5414}
5415 5415
5416rule__CustomEntry__Group__2__Impl 5416rule__ObjectiveSpecification__Group_2__1__Impl
5417 @init { 5417 @init {
5418 int stackSize = keepStackSize(); 5418 int stackSize = keepStackSize();
5419 } 5419 }
5420: 5420:
5421( 5421(
5422 { before(grammarAccess.getCustomEntryAccess().getValueAssignment_2()); } 5422 { before(grammarAccess.getObjectiveSpecificationAccess().getEntriesAssignment_2_1()); }
5423 (rule__CustomEntry__ValueAssignment_2) 5423 (rule__ObjectiveSpecification__EntriesAssignment_2_1)
5424 { after(grammarAccess.getCustomEntryAccess().getValueAssignment_2()); } 5424 { after(grammarAccess.getObjectiveSpecificationAccess().getEntriesAssignment_2_1()); }
5425) 5425)
5426; 5426;
5427finally { 5427finally {
5428 restoreStackSize(stackSize); 5428 restoreStackSize(stackSize);
5429} 5429}
5430 5430
5431 5431
5432rule__ScopeSpecification__Group__0 5432rule__OptimizationEntry__Group__0
5433 @init { 5433 @init {
5434 int stackSize = keepStackSize(); 5434 int stackSize = keepStackSize();
5435 } 5435 }
5436: 5436:
5437 rule__ScopeSpecification__Group__0__Impl 5437 rule__OptimizationEntry__Group__0__Impl
5438 rule__ScopeSpecification__Group__1 5438 rule__OptimizationEntry__Group__1
5439; 5439;
5440finally { 5440finally {
5441 restoreStackSize(stackSize); 5441 restoreStackSize(stackSize);
5442} 5442}
5443 5443
5444rule__ScopeSpecification__Group__0__Impl 5444rule__OptimizationEntry__Group__0__Impl
5445 @init { 5445 @init {
5446 int stackSize = keepStackSize(); 5446 int stackSize = keepStackSize();
5447 } 5447 }
5448: 5448:
5449( 5449(
5450 { before(grammarAccess.getScopeSpecificationAccess().getScopeSpecificationAction_0()); } 5450 { before(grammarAccess.getOptimizationEntryAccess().getDirectionAssignment_0()); }
5451 () 5451 (rule__OptimizationEntry__DirectionAssignment_0)
5452 { after(grammarAccess.getScopeSpecificationAccess().getScopeSpecificationAction_0()); } 5452 { after(grammarAccess.getOptimizationEntryAccess().getDirectionAssignment_0()); }
5453) 5453)
5454; 5454;
5455finally { 5455finally {
5456 restoreStackSize(stackSize); 5456 restoreStackSize(stackSize);
5457} 5457}
5458 5458
5459rule__ScopeSpecification__Group__1 5459rule__OptimizationEntry__Group__1
5460 @init { 5460 @init {
5461 int stackSize = keepStackSize(); 5461 int stackSize = keepStackSize();
5462 } 5462 }
5463: 5463:
5464 rule__ScopeSpecification__Group__1__Impl 5464 rule__OptimizationEntry__Group__1__Impl
5465 rule__ScopeSpecification__Group__2 5465;
5466; 5466finally {
5467finally { 5467 restoreStackSize(stackSize);
5468 restoreStackSize(stackSize); 5468}
5469} 5469
5470 5470rule__OptimizationEntry__Group__1__Impl
5471rule__ScopeSpecification__Group__1__Impl 5471 @init {
5472 @init { 5472 int stackSize = keepStackSize();
5473 int stackSize = keepStackSize(); 5473 }
5474 } 5474:
5475: 5475(
5476( 5476 { before(grammarAccess.getOptimizationEntryAccess().getFunctionAssignment_1()); }
5477 { before(grammarAccess.getScopeSpecificationAccess().getLeftCurlyBracketKeyword_1()); } 5477 (rule__OptimizationEntry__FunctionAssignment_1)
5478 '{' 5478 { after(grammarAccess.getOptimizationEntryAccess().getFunctionAssignment_1()); }
5479 { after(grammarAccess.getScopeSpecificationAccess().getLeftCurlyBracketKeyword_1()); } 5479)
5480) 5480;
5481; 5481finally {
5482finally { 5482 restoreStackSize(stackSize);
5483 restoreStackSize(stackSize); 5483}
5484} 5484
5485 5485
5486rule__ScopeSpecification__Group__2 5486rule__ThresholdEntry__Group__0
5487 @init { 5487 @init {
5488 int stackSize = keepStackSize(); 5488 int stackSize = keepStackSize();
5489 } 5489 }
5490: 5490:
5491 rule__ScopeSpecification__Group__2__Impl 5491 rule__ThresholdEntry__Group__0__Impl
5492 rule__ScopeSpecification__Group__3 5492 rule__ThresholdEntry__Group__1
5493; 5493;
5494finally { 5494finally {
5495 restoreStackSize(stackSize); 5495 restoreStackSize(stackSize);
5496} 5496}
5497 5497
5498rule__ScopeSpecification__Group__2__Impl 5498rule__ThresholdEntry__Group__0__Impl
5499 @init { 5499 @init {
5500 int stackSize = keepStackSize(); 5500 int stackSize = keepStackSize();
5501 } 5501 }
5502: 5502:
5503( 5503(
5504 { before(grammarAccess.getScopeSpecificationAccess().getGroup_2()); } 5504 { before(grammarAccess.getThresholdEntryAccess().getFunctionAssignment_0()); }
5505 (rule__ScopeSpecification__Group_2__0)? 5505 (rule__ThresholdEntry__FunctionAssignment_0)
5506 { after(grammarAccess.getScopeSpecificationAccess().getGroup_2()); } 5506 { after(grammarAccess.getThresholdEntryAccess().getFunctionAssignment_0()); }
5507) 5507)
5508; 5508;
5509finally { 5509finally {
5510 restoreStackSize(stackSize); 5510 restoreStackSize(stackSize);
5511} 5511}
5512 5512
5513rule__ScopeSpecification__Group__3 5513rule__ThresholdEntry__Group__1
5514 @init { 5514 @init {
5515 int stackSize = keepStackSize(); 5515 int stackSize = keepStackSize();
5516 } 5516 }
5517: 5517:
5518 rule__ScopeSpecification__Group__3__Impl 5518 rule__ThresholdEntry__Group__1__Impl
5519; 5519 rule__ThresholdEntry__Group__2
5520finally { 5520;
5521 restoreStackSize(stackSize); 5521finally {
5522} 5522 restoreStackSize(stackSize);
5523 5523}
5524rule__ScopeSpecification__Group__3__Impl 5524
5525 @init { 5525rule__ThresholdEntry__Group__1__Impl
5526 int stackSize = keepStackSize(); 5526 @init {
5527 } 5527 int stackSize = keepStackSize();
5528: 5528 }
5529( 5529:
5530 { before(grammarAccess.getScopeSpecificationAccess().getRightCurlyBracketKeyword_3()); } 5530(
5531 '}' 5531 { before(grammarAccess.getThresholdEntryAccess().getOperatorAssignment_1()); }
5532 { after(grammarAccess.getScopeSpecificationAccess().getRightCurlyBracketKeyword_3()); } 5532 (rule__ThresholdEntry__OperatorAssignment_1)
5533) 5533 { after(grammarAccess.getThresholdEntryAccess().getOperatorAssignment_1()); }
5534; 5534)
5535finally { 5535;
5536 restoreStackSize(stackSize); 5536finally {
5537} 5537 restoreStackSize(stackSize);
5538 5538}
5539 5539
5540rule__ScopeSpecification__Group_2__0 5540rule__ThresholdEntry__Group__2
5541 @init { 5541 @init {
5542 int stackSize = keepStackSize(); 5542 int stackSize = keepStackSize();
5543 } 5543 }
5544: 5544:
5545 rule__ScopeSpecification__Group_2__0__Impl 5545 rule__ThresholdEntry__Group__2__Impl
5546 rule__ScopeSpecification__Group_2__1 5546;
5547; 5547finally {
5548finally { 5548 restoreStackSize(stackSize);
5549 restoreStackSize(stackSize); 5549}
5550} 5550
5551 5551rule__ThresholdEntry__Group__2__Impl
5552rule__ScopeSpecification__Group_2__0__Impl 5552 @init {
5553 @init { 5553 int stackSize = keepStackSize();
5554 int stackSize = keepStackSize(); 5554 }
5555 } 5555:
5556: 5556(
5557( 5557 { before(grammarAccess.getThresholdEntryAccess().getThresholdAssignment_2()); }
5558 { before(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_0()); } 5558 (rule__ThresholdEntry__ThresholdAssignment_2)
5559 (rule__ScopeSpecification__ScopesAssignment_2_0) 5559 { after(grammarAccess.getThresholdEntryAccess().getThresholdAssignment_2()); }
5560 { after(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_0()); } 5560)
5561) 5561;
5562; 5562finally {
5563finally { 5563 restoreStackSize(stackSize);
5564 restoreStackSize(stackSize); 5564}
5565} 5565
5566 5566
5567rule__ScopeSpecification__Group_2__1 5567rule__ReliabiltiyFunction__Group__0
5568 @init { 5568 @init {
5569 int stackSize = keepStackSize(); 5569 int stackSize = keepStackSize();
5570 } 5570 }
5571: 5571:
5572 rule__ScopeSpecification__Group_2__1__Impl 5572 rule__ReliabiltiyFunction__Group__0__Impl
5573; 5573 rule__ReliabiltiyFunction__Group__1
5574finally { 5574;
5575 restoreStackSize(stackSize); 5575finally {
5576} 5576 restoreStackSize(stackSize);
5577 5577}
5578rule__ScopeSpecification__Group_2__1__Impl 5578
5579 @init { 5579rule__ReliabiltiyFunction__Group__0__Impl
5580 int stackSize = keepStackSize(); 5580 @init {
5581 } 5581 int stackSize = keepStackSize();
5582: 5582 }
5583( 5583:
5584 { before(grammarAccess.getScopeSpecificationAccess().getGroup_2_1()); } 5584(
5585 (rule__ScopeSpecification__Group_2_1__0)* 5585 { before(grammarAccess.getReliabiltiyFunctionAccess().getReliabilityKeyword_0()); }
5586 { after(grammarAccess.getScopeSpecificationAccess().getGroup_2_1()); } 5586 'reliability'
5587) 5587 { after(grammarAccess.getReliabiltiyFunctionAccess().getReliabilityKeyword_0()); }
5588; 5588)
5589finally { 5589;
5590 restoreStackSize(stackSize); 5590finally {
5591} 5591 restoreStackSize(stackSize);
5592 5592}
5593 5593
5594rule__ScopeSpecification__Group_2_1__0 5594rule__ReliabiltiyFunction__Group__1
5595 @init { 5595 @init {
5596 int stackSize = keepStackSize(); 5596 int stackSize = keepStackSize();
5597 } 5597 }
5598: 5598:
5599 rule__ScopeSpecification__Group_2_1__0__Impl 5599 rule__ReliabiltiyFunction__Group__1__Impl
5600 rule__ScopeSpecification__Group_2_1__1 5600 rule__ReliabiltiyFunction__Group__2
5601; 5601;
5602finally { 5602finally {
5603 restoreStackSize(stackSize); 5603 restoreStackSize(stackSize);
5604} 5604}
5605 5605
5606rule__ScopeSpecification__Group_2_1__0__Impl 5606rule__ReliabiltiyFunction__Group__1__Impl
5607 @init { 5607 @init {
5608 int stackSize = keepStackSize(); 5608 int stackSize = keepStackSize();
5609 } 5609 }
5610: 5610:
5611( 5611(
5612 { before(grammarAccess.getScopeSpecificationAccess().getCommaKeyword_2_1_0()); } 5612 { before(grammarAccess.getReliabiltiyFunctionAccess().getGroup_1()); }
5613 ',' 5613 (rule__ReliabiltiyFunction__Group_1__0)?
5614 { after(grammarAccess.getScopeSpecificationAccess().getCommaKeyword_2_1_0()); } 5614 { after(grammarAccess.getReliabiltiyFunctionAccess().getGroup_1()); }
5615) 5615)
5616; 5616;
5617finally { 5617finally {
5618 restoreStackSize(stackSize); 5618 restoreStackSize(stackSize);
5619} 5619}
5620 5620
5621rule__ScopeSpecification__Group_2_1__1 5621rule__ReliabiltiyFunction__Group__2
5622 @init { 5622 @init {
5623 int stackSize = keepStackSize(); 5623 int stackSize = keepStackSize();
5624 } 5624 }
5625: 5625:
5626 rule__ScopeSpecification__Group_2_1__1__Impl 5626 rule__ReliabiltiyFunction__Group__2__Impl
5627; 5627;
5628finally { 5628finally {
5629 restoreStackSize(stackSize); 5629 restoreStackSize(stackSize);
5630} 5630}
5631 5631
5632rule__ScopeSpecification__Group_2_1__1__Impl 5632rule__ReliabiltiyFunction__Group__2__Impl
5633 @init { 5633 @init {
5634 int stackSize = keepStackSize(); 5634 int stackSize = keepStackSize();
5635 } 5635 }
5636: 5636:
5637( 5637(
5638 { before(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_1_1()); } 5638 { before(grammarAccess.getReliabiltiyFunctionAccess().getTransformationAssignment_2()); }
5639 (rule__ScopeSpecification__ScopesAssignment_2_1_1) 5639 (rule__ReliabiltiyFunction__TransformationAssignment_2)
5640 { after(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_1_1()); } 5640 { after(grammarAccess.getReliabiltiyFunctionAccess().getTransformationAssignment_2()); }
5641) 5641)
5642; 5642;
5643finally { 5643finally {
5644 restoreStackSize(stackSize); 5644 restoreStackSize(stackSize);
5645} 5645}
5646 5646
5647 5647
5648rule__ClassTypeScope__Group__0 5648rule__ReliabiltiyFunction__Group_1__0
5649 @init { 5649 @init {
5650 int stackSize = keepStackSize(); 5650 int stackSize = keepStackSize();
5651 } 5651 }
5652: 5652:
5653 rule__ClassTypeScope__Group__0__Impl 5653 rule__ReliabiltiyFunction__Group_1__0__Impl
5654 rule__ClassTypeScope__Group__1 5654 rule__ReliabiltiyFunction__Group_1__1
5655; 5655;
5656finally { 5656finally {
5657 restoreStackSize(stackSize); 5657 restoreStackSize(stackSize);
5658} 5658}
5659 5659
5660rule__ClassTypeScope__Group__0__Impl 5660rule__ReliabiltiyFunction__Group_1__0__Impl
5661 @init { 5661 @init {
5662 int stackSize = keepStackSize(); 5662 int stackSize = keepStackSize();
5663 } 5663 }
5664: 5664:
5665( 5665(
5666 { before(grammarAccess.getClassTypeScopeAccess().getNumberSignKeyword_0()); } 5666 { before(grammarAccess.getReliabiltiyFunctionAccess().getPackageAssignment_1_0()); }
5667 '#' 5667 (rule__ReliabiltiyFunction__PackageAssignment_1_0)
5668 { after(grammarAccess.getClassTypeScopeAccess().getNumberSignKeyword_0()); } 5668 { after(grammarAccess.getReliabiltiyFunctionAccess().getPackageAssignment_1_0()); }
5669) 5669)
5670; 5670;
5671finally { 5671finally {
5672 restoreStackSize(stackSize); 5672 restoreStackSize(stackSize);
5673} 5673}
5674 5674
5675rule__ClassTypeScope__Group__1 5675rule__ReliabiltiyFunction__Group_1__1
5676 @init { 5676 @init {
5677 int stackSize = keepStackSize(); 5677 int stackSize = keepStackSize();
5678 } 5678 }
5679: 5679:
5680 rule__ClassTypeScope__Group__1__Impl 5680 rule__ReliabiltiyFunction__Group_1__1__Impl
5681 rule__ClassTypeScope__Group__2 5681;
5682; 5682finally {
5683finally { 5683 restoreStackSize(stackSize);
5684 restoreStackSize(stackSize); 5684}
5685} 5685
5686 5686rule__ReliabiltiyFunction__Group_1__1__Impl
5687rule__ClassTypeScope__Group__1__Impl 5687 @init {
5688 @init { 5688 int stackSize = keepStackSize();
5689 int stackSize = keepStackSize(); 5689 }
5690 } 5690:
5691: 5691(
5692( 5692 { before(grammarAccess.getReliabiltiyFunctionAccess().getColonColonKeyword_1_1()); }
5693 { before(grammarAccess.getClassTypeScopeAccess().getTypeAssignment_1()); } 5693 '::'
5694 (rule__ClassTypeScope__TypeAssignment_1) 5694 { after(grammarAccess.getReliabiltiyFunctionAccess().getColonColonKeyword_1_1()); }
5695 { after(grammarAccess.getClassTypeScopeAccess().getTypeAssignment_1()); } 5695)
5696) 5696;
5697; 5697finally {
5698finally { 5698 restoreStackSize(stackSize);
5699 restoreStackSize(stackSize); 5699}
5700} 5700
5701 5701
5702rule__ClassTypeScope__Group__2 5702rule__ObjectiveDeclaration__Group__0
5703 @init { 5703 @init {
5704 int stackSize = keepStackSize(); 5704 int stackSize = keepStackSize();
5705 } 5705 }
5706: 5706:
5707 rule__ClassTypeScope__Group__2__Impl 5707 rule__ObjectiveDeclaration__Group__0__Impl
5708 rule__ClassTypeScope__Group__3 5708 rule__ObjectiveDeclaration__Group__1
5709; 5709;
5710finally { 5710finally {
5711 restoreStackSize(stackSize); 5711 restoreStackSize(stackSize);
5712} 5712}
5713 5713
5714rule__ClassTypeScope__Group__2__Impl 5714rule__ObjectiveDeclaration__Group__0__Impl
5715 @init { 5715 @init {
5716 int stackSize = keepStackSize(); 5716 int stackSize = keepStackSize();
5717 } 5717 }
5718: 5718:
5719( 5719(
5720 { before(grammarAccess.getClassTypeScopeAccess().getAlternatives_2()); } 5720 { before(grammarAccess.getObjectiveDeclarationAccess().getObjectivesKeyword_0()); }
5721 (rule__ClassTypeScope__Alternatives_2) 5721 'objectives'
5722 { after(grammarAccess.getClassTypeScopeAccess().getAlternatives_2()); } 5722 { after(grammarAccess.getObjectiveDeclarationAccess().getObjectivesKeyword_0()); }
5723) 5723)
5724; 5724;
5725finally { 5725finally {
5726 restoreStackSize(stackSize); 5726 restoreStackSize(stackSize);
5727} 5727}
5728 5728
5729rule__ClassTypeScope__Group__3 5729rule__ObjectiveDeclaration__Group__1
5730 @init { 5730 @init {
5731 int stackSize = keepStackSize(); 5731 int stackSize = keepStackSize();
5732 } 5732 }
5733: 5733:
5734 rule__ClassTypeScope__Group__3__Impl 5734 rule__ObjectiveDeclaration__Group__1__Impl
5735; 5735 rule__ObjectiveDeclaration__Group__2
5736finally { 5736;
5737 restoreStackSize(stackSize); 5737finally {
5738} 5738 restoreStackSize(stackSize);
5739 5739}
5740rule__ClassTypeScope__Group__3__Impl 5740
5741 @init { 5741rule__ObjectiveDeclaration__Group__1__Impl
5742 int stackSize = keepStackSize(); 5742 @init {
5743 } 5743 int stackSize = keepStackSize();
5744: 5744 }
5745( 5745:
5746 { before(grammarAccess.getClassTypeScopeAccess().getAlternatives_3()); } 5746(
5747 (rule__ClassTypeScope__Alternatives_3) 5747 { before(grammarAccess.getObjectiveDeclarationAccess().getNameAssignment_1()); }
5748 { after(grammarAccess.getClassTypeScopeAccess().getAlternatives_3()); } 5748 (rule__ObjectiveDeclaration__NameAssignment_1)
5749) 5749 { after(grammarAccess.getObjectiveDeclarationAccess().getNameAssignment_1()); }
5750; 5750)
5751finally { 5751;
5752 restoreStackSize(stackSize); 5752finally {
5753} 5753 restoreStackSize(stackSize);
5754 5754}
5755 5755
5756rule__ObjectTypeScope__Group__0 5756rule__ObjectiveDeclaration__Group__2
5757 @init { 5757 @init {
5758 int stackSize = keepStackSize(); 5758 int stackSize = keepStackSize();
5759 } 5759 }
5760: 5760:
5761 rule__ObjectTypeScope__Group__0__Impl 5761 rule__ObjectiveDeclaration__Group__2__Impl
5762 rule__ObjectTypeScope__Group__1 5762;
5763; 5763finally {
5764finally { 5764 restoreStackSize(stackSize);
5765 restoreStackSize(stackSize); 5765}
5766} 5766
5767 5767rule__ObjectiveDeclaration__Group__2__Impl
5768rule__ObjectTypeScope__Group__0__Impl 5768 @init {
5769 @init { 5769 int stackSize = keepStackSize();
5770 int stackSize = keepStackSize(); 5770 }
5771 } 5771:
5772: 5772(
5773( 5773 { before(grammarAccess.getObjectiveDeclarationAccess().getSpecificationAssignment_2()); }
5774 { before(grammarAccess.getObjectTypeScopeAccess().getNumberSignKeyword_0()); } 5774 (rule__ObjectiveDeclaration__SpecificationAssignment_2)
5775 '#' 5775 { after(grammarAccess.getObjectiveDeclarationAccess().getSpecificationAssignment_2()); }
5776 { after(grammarAccess.getObjectTypeScopeAccess().getNumberSignKeyword_0()); } 5776)
5777) 5777;
5778; 5778finally {
5779finally { 5779 restoreStackSize(stackSize);
5780 restoreStackSize(stackSize); 5780}
5781} 5781
5782 5782
5783rule__ObjectTypeScope__Group__1 5783rule__ConfigSpecification__Group__0
5784 @init { 5784 @init {
5785 int stackSize = keepStackSize(); 5785 int stackSize = keepStackSize();
5786 } 5786 }
5787: 5787:
5788 rule__ObjectTypeScope__Group__1__Impl 5788 rule__ConfigSpecification__Group__0__Impl
5789 rule__ObjectTypeScope__Group__2 5789 rule__ConfigSpecification__Group__1
5790; 5790;
5791finally { 5791finally {
5792 restoreStackSize(stackSize); 5792 restoreStackSize(stackSize);
5793} 5793}
5794 5794
5795rule__ObjectTypeScope__Group__1__Impl 5795rule__ConfigSpecification__Group__0__Impl
5796 @init { 5796 @init {
5797 int stackSize = keepStackSize(); 5797 int stackSize = keepStackSize();
5798 } 5798 }
5799: 5799:
5800( 5800(
5801 { before(grammarAccess.getObjectTypeScopeAccess().getTypeAssignment_1()); } 5801 { before(grammarAccess.getConfigSpecificationAccess().getConfigSpecificationAction_0()); }
5802 (rule__ObjectTypeScope__TypeAssignment_1) 5802 ()
5803 { after(grammarAccess.getObjectTypeScopeAccess().getTypeAssignment_1()); } 5803 { after(grammarAccess.getConfigSpecificationAccess().getConfigSpecificationAction_0()); }
5804) 5804)
5805; 5805;
5806finally { 5806finally {
5807 restoreStackSize(stackSize); 5807 restoreStackSize(stackSize);
5808} 5808}
5809 5809
5810rule__ObjectTypeScope__Group__2 5810rule__ConfigSpecification__Group__1
5811 @init { 5811 @init {
5812 int stackSize = keepStackSize(); 5812 int stackSize = keepStackSize();
5813 } 5813 }
5814: 5814:
5815 rule__ObjectTypeScope__Group__2__Impl 5815 rule__ConfigSpecification__Group__1__Impl
5816 rule__ObjectTypeScope__Group__3 5816 rule__ConfigSpecification__Group__2
5817; 5817;
5818finally { 5818finally {
5819 restoreStackSize(stackSize); 5819 restoreStackSize(stackSize);
5820} 5820}
5821 5821
5822rule__ObjectTypeScope__Group__2__Impl 5822rule__ConfigSpecification__Group__1__Impl
5823 @init { 5823 @init {
5824 int stackSize = keepStackSize(); 5824 int stackSize = keepStackSize();
5825 } 5825 }
5826: 5826:
5827( 5827(
5828 { before(grammarAccess.getObjectTypeScopeAccess().getAlternatives_2()); } 5828 { before(grammarAccess.getConfigSpecificationAccess().getLeftCurlyBracketKeyword_1()); }
5829 (rule__ObjectTypeScope__Alternatives_2) 5829 '{'
5830 { after(grammarAccess.getObjectTypeScopeAccess().getAlternatives_2()); } 5830 { after(grammarAccess.getConfigSpecificationAccess().getLeftCurlyBracketKeyword_1()); }
5831) 5831)
5832; 5832;
5833finally { 5833finally {
5834 restoreStackSize(stackSize); 5834 restoreStackSize(stackSize);
5835} 5835}
5836 5836
5837rule__ObjectTypeScope__Group__3 5837rule__ConfigSpecification__Group__2
5838 @init { 5838 @init {
5839 int stackSize = keepStackSize(); 5839 int stackSize = keepStackSize();
5840 } 5840 }
5841: 5841:
5842 rule__ObjectTypeScope__Group__3__Impl 5842 rule__ConfigSpecification__Group__2__Impl
5843; 5843 rule__ConfigSpecification__Group__3
5844finally { 5844;
5845 restoreStackSize(stackSize); 5845finally {
5846} 5846 restoreStackSize(stackSize);
5847 5847}
5848rule__ObjectTypeScope__Group__3__Impl 5848
5849 @init { 5849rule__ConfigSpecification__Group__2__Impl
5850 int stackSize = keepStackSize(); 5850 @init {
5851 } 5851 int stackSize = keepStackSize();
5852: 5852 }
5853( 5853:
5854 { before(grammarAccess.getObjectTypeScopeAccess().getAlternatives_3()); } 5854(
5855 (rule__ObjectTypeScope__Alternatives_3) 5855 { before(grammarAccess.getConfigSpecificationAccess().getGroup_2()); }
5856 { after(grammarAccess.getObjectTypeScopeAccess().getAlternatives_3()); } 5856 (rule__ConfigSpecification__Group_2__0)?
5857) 5857 { after(grammarAccess.getConfigSpecificationAccess().getGroup_2()); }
5858; 5858)
5859finally { 5859;
5860 restoreStackSize(stackSize); 5860finally {
5861} 5861 restoreStackSize(stackSize);
5862 5862}
5863 5863
5864rule__IntegerTypeScope__Group__0 5864rule__ConfigSpecification__Group__3
5865 @init { 5865 @init {
5866 int stackSize = keepStackSize(); 5866 int stackSize = keepStackSize();
5867 } 5867 }
5868: 5868:
5869 rule__IntegerTypeScope__Group__0__Impl 5869 rule__ConfigSpecification__Group__3__Impl
5870 rule__IntegerTypeScope__Group__1 5870;
5871; 5871finally {
5872finally { 5872 restoreStackSize(stackSize);
5873 restoreStackSize(stackSize); 5873}
5874} 5874
5875 5875rule__ConfigSpecification__Group__3__Impl
5876rule__IntegerTypeScope__Group__0__Impl 5876 @init {
5877 @init { 5877 int stackSize = keepStackSize();
5878 int stackSize = keepStackSize(); 5878 }
5879 } 5879:
5880: 5880(
5881( 5881 { before(grammarAccess.getConfigSpecificationAccess().getRightCurlyBracketKeyword_3()); }
5882 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberSignKeyword_0()); } 5882 '}'
5883 '#' 5883 { after(grammarAccess.getConfigSpecificationAccess().getRightCurlyBracketKeyword_3()); }
5884 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberSignKeyword_0()); } 5884)
5885) 5885;
5886; 5886finally {
5887finally { 5887 restoreStackSize(stackSize);
5888 restoreStackSize(stackSize); 5888}
5889} 5889
5890 5890
5891rule__IntegerTypeScope__Group__1 5891rule__ConfigSpecification__Group_2__0
5892 @init { 5892 @init {
5893 int stackSize = keepStackSize(); 5893 int stackSize = keepStackSize();
5894 } 5894 }
5895: 5895:
5896 rule__IntegerTypeScope__Group__1__Impl 5896 rule__ConfigSpecification__Group_2__0__Impl
5897 rule__IntegerTypeScope__Group__2 5897 rule__ConfigSpecification__Group_2__1
5898; 5898;
5899finally { 5899finally {
5900 restoreStackSize(stackSize); 5900 restoreStackSize(stackSize);
5901} 5901}
5902 5902
5903rule__IntegerTypeScope__Group__1__Impl 5903rule__ConfigSpecification__Group_2__0__Impl
5904 @init { 5904 @init {
5905 int stackSize = keepStackSize(); 5905 int stackSize = keepStackSize();
5906 } 5906 }
5907: 5907:
5908( 5908(
5909 { before(grammarAccess.getIntegerTypeScopeAccess().getTypeAssignment_1()); } 5909 { before(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_0()); }
5910 (rule__IntegerTypeScope__TypeAssignment_1) 5910 (rule__ConfigSpecification__EntriesAssignment_2_0)
5911 { after(grammarAccess.getIntegerTypeScopeAccess().getTypeAssignment_1()); } 5911 { after(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_0()); }
5912) 5912)
5913; 5913;
5914finally { 5914finally {
5915 restoreStackSize(stackSize); 5915 restoreStackSize(stackSize);
5916} 5916}
5917 5917
5918rule__IntegerTypeScope__Group__2 5918rule__ConfigSpecification__Group_2__1
5919 @init { 5919 @init {
5920 int stackSize = keepStackSize(); 5920 int stackSize = keepStackSize();
5921 } 5921 }
5922: 5922:
5923 rule__IntegerTypeScope__Group__2__Impl 5923 rule__ConfigSpecification__Group_2__1__Impl
5924 rule__IntegerTypeScope__Group__3 5924;
5925; 5925finally {
5926finally { 5926 restoreStackSize(stackSize);
5927 restoreStackSize(stackSize); 5927}
5928} 5928
5929 5929rule__ConfigSpecification__Group_2__1__Impl
5930rule__IntegerTypeScope__Group__2__Impl 5930 @init {
5931 @init { 5931 int stackSize = keepStackSize();
5932 int stackSize = keepStackSize(); 5932 }
5933 } 5933:
5934: 5934(
5935( 5935 { before(grammarAccess.getConfigSpecificationAccess().getGroup_2_1()); }
5936 { before(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_2()); } 5936 (rule__ConfigSpecification__Group_2_1__0)*
5937 (rule__IntegerTypeScope__Alternatives_2) 5937 { after(grammarAccess.getConfigSpecificationAccess().getGroup_2_1()); }
5938 { after(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_2()); } 5938)
5939) 5939;
5940; 5940finally {
5941finally { 5941 restoreStackSize(stackSize);
5942 restoreStackSize(stackSize); 5942}
5943} 5943
5944 5944
5945rule__IntegerTypeScope__Group__3 5945rule__ConfigSpecification__Group_2_1__0
5946 @init { 5946 @init {
5947 int stackSize = keepStackSize(); 5947 int stackSize = keepStackSize();
5948 } 5948 }
5949: 5949:
5950 rule__IntegerTypeScope__Group__3__Impl 5950 rule__ConfigSpecification__Group_2_1__0__Impl
5951; 5951 rule__ConfigSpecification__Group_2_1__1
5952finally { 5952;
5953 restoreStackSize(stackSize); 5953finally {
5954} 5954 restoreStackSize(stackSize);
5955 5955}
5956rule__IntegerTypeScope__Group__3__Impl 5956
5957 @init { 5957rule__ConfigSpecification__Group_2_1__0__Impl
5958 int stackSize = keepStackSize(); 5958 @init {
5959 } 5959 int stackSize = keepStackSize();
5960: 5960 }
5961( 5961:
5962 { before(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_3()); } 5962(
5963 (rule__IntegerTypeScope__Alternatives_3) 5963 { before(grammarAccess.getConfigSpecificationAccess().getCommaKeyword_2_1_0()); }
5964 { after(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_3()); } 5964 ','
5965) 5965 { after(grammarAccess.getConfigSpecificationAccess().getCommaKeyword_2_1_0()); }
5966; 5966)
5967finally { 5967;
5968 restoreStackSize(stackSize); 5968finally {
5969} 5969 restoreStackSize(stackSize);
5970 5970}
5971 5971
5972rule__RealTypeScope__Group__0 5972rule__ConfigSpecification__Group_2_1__1
5973 @init { 5973 @init {
5974 int stackSize = keepStackSize(); 5974 int stackSize = keepStackSize();
5975 } 5975 }
5976: 5976:
5977 rule__RealTypeScope__Group__0__Impl 5977 rule__ConfigSpecification__Group_2_1__1__Impl
5978 rule__RealTypeScope__Group__1 5978;
5979; 5979finally {
5980finally { 5980 restoreStackSize(stackSize);
5981 restoreStackSize(stackSize); 5981}
5982} 5982
5983 5983rule__ConfigSpecification__Group_2_1__1__Impl
5984rule__RealTypeScope__Group__0__Impl 5984 @init {
5985 @init { 5985 int stackSize = keepStackSize();
5986 int stackSize = keepStackSize(); 5986 }
5987 } 5987:
5988: 5988(
5989( 5989 { before(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_1_1()); }
5990 { before(grammarAccess.getRealTypeScopeAccess().getNumberSignKeyword_0()); } 5990 (rule__ConfigSpecification__EntriesAssignment_2_1_1)
5991 '#' 5991 { after(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_1_1()); }
5992 { after(grammarAccess.getRealTypeScopeAccess().getNumberSignKeyword_0()); } 5992)
5993) 5993;
5994; 5994finally {
5995finally { 5995 restoreStackSize(stackSize);
5996 restoreStackSize(stackSize); 5996}
5997} 5997
5998 5998
5999rule__RealTypeScope__Group__1 5999rule__ConfigDeclaration__Group__0
6000 @init { 6000 @init {
6001 int stackSize = keepStackSize(); 6001 int stackSize = keepStackSize();
6002 } 6002 }
6003: 6003:
6004 rule__RealTypeScope__Group__1__Impl 6004 rule__ConfigDeclaration__Group__0__Impl
6005 rule__RealTypeScope__Group__2 6005 rule__ConfigDeclaration__Group__1
6006; 6006;
6007finally { 6007finally {
6008 restoreStackSize(stackSize); 6008 restoreStackSize(stackSize);
6009} 6009}
6010 6010
6011rule__RealTypeScope__Group__1__Impl 6011rule__ConfigDeclaration__Group__0__Impl
6012 @init { 6012 @init {
6013 int stackSize = keepStackSize(); 6013 int stackSize = keepStackSize();
6014 } 6014 }
6015: 6015:
6016( 6016(
6017 { before(grammarAccess.getRealTypeScopeAccess().getTypeAssignment_1()); } 6017 { before(grammarAccess.getConfigDeclarationAccess().getConfigKeyword_0()); }
6018 (rule__RealTypeScope__TypeAssignment_1) 6018 'config'
6019 { after(grammarAccess.getRealTypeScopeAccess().getTypeAssignment_1()); } 6019 { after(grammarAccess.getConfigDeclarationAccess().getConfigKeyword_0()); }
6020) 6020)
6021; 6021;
6022finally { 6022finally {
6023 restoreStackSize(stackSize); 6023 restoreStackSize(stackSize);
6024} 6024}
6025 6025
6026rule__RealTypeScope__Group__2 6026rule__ConfigDeclaration__Group__1
6027 @init { 6027 @init {
6028 int stackSize = keepStackSize(); 6028 int stackSize = keepStackSize();
6029 } 6029 }
6030: 6030:
6031 rule__RealTypeScope__Group__2__Impl 6031 rule__ConfigDeclaration__Group__1__Impl
6032 rule__RealTypeScope__Group__3 6032 rule__ConfigDeclaration__Group__2
6033; 6033;
6034finally { 6034finally {
6035 restoreStackSize(stackSize); 6035 restoreStackSize(stackSize);
6036} 6036}
6037 6037
6038rule__RealTypeScope__Group__2__Impl 6038rule__ConfigDeclaration__Group__1__Impl
6039 @init { 6039 @init {
6040 int stackSize = keepStackSize(); 6040 int stackSize = keepStackSize();
6041 } 6041 }
6042: 6042:
6043( 6043(
6044 { before(grammarAccess.getRealTypeScopeAccess().getAlternatives_2()); } 6044 { before(grammarAccess.getConfigDeclarationAccess().getNameAssignment_1()); }
6045 (rule__RealTypeScope__Alternatives_2) 6045 (rule__ConfigDeclaration__NameAssignment_1)
6046 { after(grammarAccess.getRealTypeScopeAccess().getAlternatives_2()); } 6046 { after(grammarAccess.getConfigDeclarationAccess().getNameAssignment_1()); }
6047) 6047)
6048; 6048;
6049finally { 6049finally {
6050 restoreStackSize(stackSize); 6050 restoreStackSize(stackSize);
6051} 6051}
6052 6052
6053rule__RealTypeScope__Group__3 6053rule__ConfigDeclaration__Group__2
6054 @init { 6054 @init {
6055 int stackSize = keepStackSize(); 6055 int stackSize = keepStackSize();
6056 } 6056 }
6057: 6057:
6058 rule__RealTypeScope__Group__3__Impl 6058 rule__ConfigDeclaration__Group__2__Impl
6059; 6059;
6060finally { 6060finally {
6061 restoreStackSize(stackSize); 6061 restoreStackSize(stackSize);
6062} 6062}
6063 6063
6064rule__RealTypeScope__Group__3__Impl 6064rule__ConfigDeclaration__Group__2__Impl
6065 @init { 6065 @init {
6066 int stackSize = keepStackSize(); 6066 int stackSize = keepStackSize();
6067 } 6067 }
6068: 6068:
6069( 6069(
6070 { before(grammarAccess.getRealTypeScopeAccess().getAlternatives_3()); } 6070 { before(grammarAccess.getConfigDeclarationAccess().getSpecificationAssignment_2()); }
6071 (rule__RealTypeScope__Alternatives_3) 6071 (rule__ConfigDeclaration__SpecificationAssignment_2)
6072 { after(grammarAccess.getRealTypeScopeAccess().getAlternatives_3()); } 6072 { after(grammarAccess.getConfigDeclarationAccess().getSpecificationAssignment_2()); }
6073) 6073)
6074; 6074;
6075finally { 6075finally {
6076 restoreStackSize(stackSize); 6076 restoreStackSize(stackSize);
6077} 6077}
6078 6078
6079 6079
6080rule__StringTypeScope__Group__0 6080rule__DocumentationEntry__Group__0
6081 @init { 6081 @init {
6082 int stackSize = keepStackSize(); 6082 int stackSize = keepStackSize();
6083 } 6083 }
6084: 6084:
6085 rule__StringTypeScope__Group__0__Impl 6085 rule__DocumentationEntry__Group__0__Impl
6086 rule__StringTypeScope__Group__1 6086 rule__DocumentationEntry__Group__1
6087; 6087;
6088finally { 6088finally {
6089 restoreStackSize(stackSize); 6089 restoreStackSize(stackSize);
6090} 6090}
6091 6091
6092rule__StringTypeScope__Group__0__Impl 6092rule__DocumentationEntry__Group__0__Impl
6093 @init { 6093 @init {
6094 int stackSize = keepStackSize(); 6094 int stackSize = keepStackSize();
6095 } 6095 }
6096: 6096:
6097( 6097(
6098 { before(grammarAccess.getStringTypeScopeAccess().getNumberSignKeyword_0()); } 6098 { before(grammarAccess.getDocumentationEntryAccess().getLogLevelKeyword_0()); }
6099 '#' 6099 'log-level'
6100 { after(grammarAccess.getStringTypeScopeAccess().getNumberSignKeyword_0()); } 6100 { after(grammarAccess.getDocumentationEntryAccess().getLogLevelKeyword_0()); }
6101) 6101)
6102; 6102;
6103finally { 6103finally {
6104 restoreStackSize(stackSize); 6104 restoreStackSize(stackSize);
6105} 6105}
6106 6106
6107rule__StringTypeScope__Group__1 6107rule__DocumentationEntry__Group__1
6108 @init { 6108 @init {
6109 int stackSize = keepStackSize(); 6109 int stackSize = keepStackSize();
6110 } 6110 }
6111: 6111:
6112 rule__StringTypeScope__Group__1__Impl 6112 rule__DocumentationEntry__Group__1__Impl
6113 rule__StringTypeScope__Group__2 6113 rule__DocumentationEntry__Group__2
6114; 6114;
6115finally { 6115finally {
6116 restoreStackSize(stackSize); 6116 restoreStackSize(stackSize);
6117} 6117}
6118 6118
6119rule__StringTypeScope__Group__1__Impl 6119rule__DocumentationEntry__Group__1__Impl
6120 @init { 6120 @init {
6121 int stackSize = keepStackSize(); 6121 int stackSize = keepStackSize();
6122 } 6122 }
6123: 6123:
6124( 6124(
6125 { before(grammarAccess.getStringTypeScopeAccess().getTypeAssignment_1()); } 6125 { before(grammarAccess.getDocumentationEntryAccess().getEqualsSignKeyword_1()); }
6126 (rule__StringTypeScope__TypeAssignment_1) 6126 '='
6127 { after(grammarAccess.getStringTypeScopeAccess().getTypeAssignment_1()); } 6127 { after(grammarAccess.getDocumentationEntryAccess().getEqualsSignKeyword_1()); }
6128) 6128)
6129; 6129;
6130finally { 6130finally {
6131 restoreStackSize(stackSize); 6131 restoreStackSize(stackSize);
6132} 6132}
6133 6133
6134rule__StringTypeScope__Group__2 6134rule__DocumentationEntry__Group__2
6135 @init { 6135 @init {
6136 int stackSize = keepStackSize(); 6136 int stackSize = keepStackSize();
6137 } 6137 }
6138: 6138:
6139 rule__StringTypeScope__Group__2__Impl 6139 rule__DocumentationEntry__Group__2__Impl
6140 rule__StringTypeScope__Group__3 6140;
6141; 6141finally {
6142finally { 6142 restoreStackSize(stackSize);
6143 restoreStackSize(stackSize); 6143}
6144} 6144
6145 6145rule__DocumentationEntry__Group__2__Impl
6146rule__StringTypeScope__Group__2__Impl 6146 @init {
6147 @init { 6147 int stackSize = keepStackSize();
6148 int stackSize = keepStackSize(); 6148 }
6149 } 6149:
6150: 6150(
6151( 6151 { before(grammarAccess.getDocumentationEntryAccess().getLevelAssignment_2()); }
6152 { before(grammarAccess.getStringTypeScopeAccess().getAlternatives_2()); } 6152 (rule__DocumentationEntry__LevelAssignment_2)
6153 (rule__StringTypeScope__Alternatives_2) 6153 { after(grammarAccess.getDocumentationEntryAccess().getLevelAssignment_2()); }
6154 { after(grammarAccess.getStringTypeScopeAccess().getAlternatives_2()); } 6154)
6155) 6155;
6156; 6156finally {
6157finally { 6157 restoreStackSize(stackSize);
6158 restoreStackSize(stackSize); 6158}
6159} 6159
6160 6160
6161rule__StringTypeScope__Group__3 6161rule__RuntimeEntry__Group__0
6162 @init { 6162 @init {
6163 int stackSize = keepStackSize(); 6163 int stackSize = keepStackSize();
6164 } 6164 }
6165: 6165:
6166 rule__StringTypeScope__Group__3__Impl 6166 rule__RuntimeEntry__Group__0__Impl
6167; 6167 rule__RuntimeEntry__Group__1
6168finally { 6168;
6169 restoreStackSize(stackSize); 6169finally {
6170} 6170 restoreStackSize(stackSize);
6171 6171}
6172rule__StringTypeScope__Group__3__Impl 6172
6173 @init { 6173rule__RuntimeEntry__Group__0__Impl
6174 int stackSize = keepStackSize(); 6174 @init {
6175 } 6175 int stackSize = keepStackSize();
6176: 6176 }
6177( 6177:
6178 { before(grammarAccess.getStringTypeScopeAccess().getAlternatives_3()); } 6178(
6179 (rule__StringTypeScope__Alternatives_3) 6179 { before(grammarAccess.getRuntimeEntryAccess().getRuntimeKeyword_0()); }
6180 { after(grammarAccess.getStringTypeScopeAccess().getAlternatives_3()); } 6180 'runtime'
6181) 6181 { after(grammarAccess.getRuntimeEntryAccess().getRuntimeKeyword_0()); }
6182; 6182)
6183finally { 6183;
6184 restoreStackSize(stackSize); 6184finally {
6185} 6185 restoreStackSize(stackSize);
6186 6186}
6187 6187
6188rule__ClassReference__Group__0 6188rule__RuntimeEntry__Group__1
6189 @init { 6189 @init {
6190 int stackSize = keepStackSize(); 6190 int stackSize = keepStackSize();
6191 } 6191 }
6192: 6192:
6193 rule__ClassReference__Group__0__Impl 6193 rule__RuntimeEntry__Group__1__Impl
6194 rule__ClassReference__Group__1 6194 rule__RuntimeEntry__Group__2
6195; 6195;
6196finally { 6196finally {
6197 restoreStackSize(stackSize); 6197 restoreStackSize(stackSize);
6198} 6198}
6199 6199
6200rule__ClassReference__Group__0__Impl 6200rule__RuntimeEntry__Group__1__Impl
6201 @init { 6201 @init {
6202 int stackSize = keepStackSize(); 6202 int stackSize = keepStackSize();
6203 } 6203 }
6204: 6204:
6205( 6205(
6206 { before(grammarAccess.getClassReferenceAccess().getLessThanSignKeyword_0()); } 6206 { before(grammarAccess.getRuntimeEntryAccess().getEqualsSignKeyword_1()); }
6207 '<' 6207 '='
6208 { after(grammarAccess.getClassReferenceAccess().getLessThanSignKeyword_0()); } 6208 { after(grammarAccess.getRuntimeEntryAccess().getEqualsSignKeyword_1()); }
6209) 6209)
6210; 6210;
6211finally { 6211finally {
6212 restoreStackSize(stackSize); 6212 restoreStackSize(stackSize);
6213} 6213}
6214 6214
6215rule__ClassReference__Group__1 6215rule__RuntimeEntry__Group__2
6216 @init { 6216 @init {
6217 int stackSize = keepStackSize(); 6217 int stackSize = keepStackSize();
6218 } 6218 }
6219: 6219:
6220 rule__ClassReference__Group__1__Impl 6220 rule__RuntimeEntry__Group__2__Impl
6221 rule__ClassReference__Group__2 6221;
6222; 6222finally {
6223finally { 6223 restoreStackSize(stackSize);
6224 restoreStackSize(stackSize); 6224}
6225} 6225
6226 6226rule__RuntimeEntry__Group__2__Impl
6227rule__ClassReference__Group__1__Impl 6227 @init {
6228 @init { 6228 int stackSize = keepStackSize();
6229 int stackSize = keepStackSize(); 6229 }
6230 } 6230:
6231: 6231(
6232( 6232 { before(grammarAccess.getRuntimeEntryAccess().getMillisecLimitAssignment_2()); }
6233 { before(grammarAccess.getClassReferenceAccess().getElementAssignment_1()); } 6233 (rule__RuntimeEntry__MillisecLimitAssignment_2)
6234 (rule__ClassReference__ElementAssignment_1) 6234 { after(grammarAccess.getRuntimeEntryAccess().getMillisecLimitAssignment_2()); }
6235 { after(grammarAccess.getClassReferenceAccess().getElementAssignment_1()); } 6235)
6236) 6236;
6237; 6237finally {
6238finally { 6238 restoreStackSize(stackSize);
6239 restoreStackSize(stackSize); 6239}
6240} 6240
6241 6241
6242rule__ClassReference__Group__2 6242rule__MemoryEntry__Group__0
6243 @init { 6243 @init {
6244 int stackSize = keepStackSize(); 6244 int stackSize = keepStackSize();
6245 } 6245 }
6246: 6246:
6247 rule__ClassReference__Group__2__Impl 6247 rule__MemoryEntry__Group__0__Impl
6248; 6248 rule__MemoryEntry__Group__1
6249finally { 6249;
6250 restoreStackSize(stackSize); 6250finally {
6251} 6251 restoreStackSize(stackSize);
6252 6252}
6253rule__ClassReference__Group__2__Impl 6253
6254 @init { 6254rule__MemoryEntry__Group__0__Impl
6255 int stackSize = keepStackSize(); 6255 @init {
6256 } 6256 int stackSize = keepStackSize();
6257: 6257 }
6258( 6258:
6259 { before(grammarAccess.getClassReferenceAccess().getGreaterThanSignKeyword_2()); } 6259(
6260 '>' 6260 { before(grammarAccess.getMemoryEntryAccess().getMemoryKeyword_0()); }
6261 { after(grammarAccess.getClassReferenceAccess().getGreaterThanSignKeyword_2()); } 6261 'memory'
6262) 6262 { after(grammarAccess.getMemoryEntryAccess().getMemoryKeyword_0()); }
6263; 6263)
6264finally { 6264;
6265 restoreStackSize(stackSize); 6265finally {
6266} 6266 restoreStackSize(stackSize);
6267 6267}
6268 6268
6269rule__ObjectReference__Group__0 6269rule__MemoryEntry__Group__1
6270 @init { 6270 @init {
6271 int stackSize = keepStackSize(); 6271 int stackSize = keepStackSize();
6272 } 6272 }
6273: 6273:
6274 rule__ObjectReference__Group__0__Impl 6274 rule__MemoryEntry__Group__1__Impl
6275 rule__ObjectReference__Group__1 6275 rule__MemoryEntry__Group__2
6276; 6276;
6277finally { 6277finally {
6278 restoreStackSize(stackSize); 6278 restoreStackSize(stackSize);
6279} 6279}
6280 6280
6281rule__ObjectReference__Group__0__Impl 6281rule__MemoryEntry__Group__1__Impl
6282 @init { 6282 @init {
6283 int stackSize = keepStackSize(); 6283 int stackSize = keepStackSize();
6284 } 6284 }
6285: 6285:
6286( 6286(
6287 { before(grammarAccess.getObjectReferenceAccess().getObjectReferenceAction_0()); } 6287 { before(grammarAccess.getMemoryEntryAccess().getEqualsSignKeyword_1()); }
6288 () 6288 '='
6289 { after(grammarAccess.getObjectReferenceAccess().getObjectReferenceAction_0()); } 6289 { after(grammarAccess.getMemoryEntryAccess().getEqualsSignKeyword_1()); }
6290) 6290)
6291; 6291;
6292finally { 6292finally {
6293 restoreStackSize(stackSize); 6293 restoreStackSize(stackSize);
6294} 6294}
6295 6295
6296rule__ObjectReference__Group__1 6296rule__MemoryEntry__Group__2
6297 @init { 6297 @init {
6298 int stackSize = keepStackSize(); 6298 int stackSize = keepStackSize();
6299 } 6299 }
6300: 6300:
6301 rule__ObjectReference__Group__1__Impl 6301 rule__MemoryEntry__Group__2__Impl
6302; 6302;
6303finally { 6303finally {
6304 restoreStackSize(stackSize); 6304 restoreStackSize(stackSize);
6305} 6305}
6306 6306
6307rule__ObjectReference__Group__1__Impl 6307rule__MemoryEntry__Group__2__Impl
6308 @init { 6308 @init {
6309 int stackSize = keepStackSize(); 6309 int stackSize = keepStackSize();
6310 } 6310 }
6311: 6311:
6312( 6312(
6313 { before(grammarAccess.getObjectReferenceAccess().getNodeKeyword_1()); } 6313 { before(grammarAccess.getMemoryEntryAccess().getMegabyteLimitAssignment_2()); }
6314 'node' 6314 (rule__MemoryEntry__MegabyteLimitAssignment_2)
6315 { after(grammarAccess.getObjectReferenceAccess().getNodeKeyword_1()); } 6315 { after(grammarAccess.getMemoryEntryAccess().getMegabyteLimitAssignment_2()); }
6316) 6316)
6317; 6317;
6318finally { 6318finally {
6319 restoreStackSize(stackSize); 6319 restoreStackSize(stackSize);
6320} 6320}
6321 6321
6322 6322
6323rule__IntegerReference__Group__0 6323rule__CustomEntry__Group__0
6324 @init { 6324 @init {
6325 int stackSize = keepStackSize(); 6325 int stackSize = keepStackSize();
6326 } 6326 }
6327: 6327:
6328 rule__IntegerReference__Group__0__Impl 6328 rule__CustomEntry__Group__0__Impl
6329 rule__IntegerReference__Group__1 6329 rule__CustomEntry__Group__1
6330; 6330;
6331finally { 6331finally {
6332 restoreStackSize(stackSize); 6332 restoreStackSize(stackSize);
6333} 6333}
6334 6334
6335rule__IntegerReference__Group__0__Impl 6335rule__CustomEntry__Group__0__Impl
6336 @init { 6336 @init {
6337 int stackSize = keepStackSize(); 6337 int stackSize = keepStackSize();
6338 } 6338 }
6339: 6339:
6340( 6340(
6341 { before(grammarAccess.getIntegerReferenceAccess().getIntegerScopeAction_0()); } 6341 { before(grammarAccess.getCustomEntryAccess().getKeyAssignment_0()); }
6342 () 6342 (rule__CustomEntry__KeyAssignment_0)
6343 { after(grammarAccess.getIntegerReferenceAccess().getIntegerScopeAction_0()); } 6343 { after(grammarAccess.getCustomEntryAccess().getKeyAssignment_0()); }
6344) 6344)
6345; 6345;
6346finally { 6346finally {
6347 restoreStackSize(stackSize); 6347 restoreStackSize(stackSize);
6348} 6348}
6349 6349
6350rule__IntegerReference__Group__1 6350rule__CustomEntry__Group__1
6351 @init { 6351 @init {
6352 int stackSize = keepStackSize(); 6352 int stackSize = keepStackSize();
6353 } 6353 }
6354: 6354:
6355 rule__IntegerReference__Group__1__Impl 6355 rule__CustomEntry__Group__1__Impl
6356; 6356 rule__CustomEntry__Group__2
6357finally { 6357;
6358 restoreStackSize(stackSize); 6358finally {
6359} 6359 restoreStackSize(stackSize);
6360 6360}
6361rule__IntegerReference__Group__1__Impl 6361
6362 @init { 6362rule__CustomEntry__Group__1__Impl
6363 int stackSize = keepStackSize(); 6363 @init {
6364 } 6364 int stackSize = keepStackSize();
6365: 6365 }
6366( 6366:
6367 { before(grammarAccess.getIntegerReferenceAccess().getIntKeyword_1()); } 6367(
6368 'int' 6368 { before(grammarAccess.getCustomEntryAccess().getEqualsSignKeyword_1()); }
6369 { after(grammarAccess.getIntegerReferenceAccess().getIntKeyword_1()); } 6369 '='
6370) 6370 { after(grammarAccess.getCustomEntryAccess().getEqualsSignKeyword_1()); }
6371; 6371)
6372finally { 6372;
6373 restoreStackSize(stackSize); 6373finally {
6374} 6374 restoreStackSize(stackSize);
6375 6375}
6376 6376
6377rule__RealReference__Group__0 6377rule__CustomEntry__Group__2
6378 @init { 6378 @init {
6379 int stackSize = keepStackSize(); 6379 int stackSize = keepStackSize();
6380 } 6380 }
6381: 6381:
6382 rule__RealReference__Group__0__Impl 6382 rule__CustomEntry__Group__2__Impl
6383 rule__RealReference__Group__1 6383;
6384; 6384finally {
6385finally { 6385 restoreStackSize(stackSize);
6386 restoreStackSize(stackSize); 6386}
6387} 6387
6388 6388rule__CustomEntry__Group__2__Impl
6389rule__RealReference__Group__0__Impl 6389 @init {
6390 @init { 6390 int stackSize = keepStackSize();
6391 int stackSize = keepStackSize(); 6391 }
6392 } 6392:
6393: 6393(
6394( 6394 { before(grammarAccess.getCustomEntryAccess().getValueAssignment_2()); }
6395 { before(grammarAccess.getRealReferenceAccess().getRealScopeAction_0()); } 6395 (rule__CustomEntry__ValueAssignment_2)
6396 () 6396 { after(grammarAccess.getCustomEntryAccess().getValueAssignment_2()); }
6397 { after(grammarAccess.getRealReferenceAccess().getRealScopeAction_0()); } 6397)
6398) 6398;
6399; 6399finally {
6400finally { 6400 restoreStackSize(stackSize);
6401 restoreStackSize(stackSize); 6401}
6402} 6402
6403 6403
6404rule__RealReference__Group__1 6404rule__ScopeSpecification__Group__0
6405 @init { 6405 @init {
6406 int stackSize = keepStackSize(); 6406 int stackSize = keepStackSize();
6407 } 6407 }
6408: 6408:
6409 rule__RealReference__Group__1__Impl 6409 rule__ScopeSpecification__Group__0__Impl
6410; 6410 rule__ScopeSpecification__Group__1
6411finally { 6411;
6412 restoreStackSize(stackSize); 6412finally {
6413} 6413 restoreStackSize(stackSize);
6414 6414}
6415rule__RealReference__Group__1__Impl 6415
6416 @init { 6416rule__ScopeSpecification__Group__0__Impl
6417 int stackSize = keepStackSize(); 6417 @init {
6418 } 6418 int stackSize = keepStackSize();
6419: 6419 }
6420( 6420:
6421 { before(grammarAccess.getRealReferenceAccess().getRealKeyword_1()); } 6421(
6422 'real' 6422 { before(grammarAccess.getScopeSpecificationAccess().getScopeSpecificationAction_0()); }
6423 { after(grammarAccess.getRealReferenceAccess().getRealKeyword_1()); } 6423 ()
6424) 6424 { after(grammarAccess.getScopeSpecificationAccess().getScopeSpecificationAction_0()); }
6425; 6425)
6426finally { 6426;
6427 restoreStackSize(stackSize); 6427finally {
6428} 6428 restoreStackSize(stackSize);
6429 6429}
6430 6430
6431rule__StringReference__Group__0 6431rule__ScopeSpecification__Group__1
6432 @init { 6432 @init {
6433 int stackSize = keepStackSize(); 6433 int stackSize = keepStackSize();
6434 } 6434 }
6435: 6435:
6436 rule__StringReference__Group__0__Impl 6436 rule__ScopeSpecification__Group__1__Impl
6437 rule__StringReference__Group__1 6437 rule__ScopeSpecification__Group__2
6438; 6438;
6439finally { 6439finally {
6440 restoreStackSize(stackSize); 6440 restoreStackSize(stackSize);
6441} 6441}
6442 6442
6443rule__StringReference__Group__0__Impl 6443rule__ScopeSpecification__Group__1__Impl
6444 @init { 6444 @init {
6445 int stackSize = keepStackSize(); 6445 int stackSize = keepStackSize();
6446 } 6446 }
6447: 6447:
6448( 6448(
6449 { before(grammarAccess.getStringReferenceAccess().getStringScopeAction_0()); } 6449 { before(grammarAccess.getScopeSpecificationAccess().getLeftCurlyBracketKeyword_1()); }
6450 () 6450 '{'
6451 { after(grammarAccess.getStringReferenceAccess().getStringScopeAction_0()); } 6451 { after(grammarAccess.getScopeSpecificationAccess().getLeftCurlyBracketKeyword_1()); }
6452) 6452)
6453; 6453;
6454finally { 6454finally {
6455 restoreStackSize(stackSize); 6455 restoreStackSize(stackSize);
6456} 6456}
6457 6457
6458rule__StringReference__Group__1 6458rule__ScopeSpecification__Group__2
6459 @init { 6459 @init {
6460 int stackSize = keepStackSize(); 6460 int stackSize = keepStackSize();
6461 } 6461 }
6462: 6462:
6463 rule__StringReference__Group__1__Impl 6463 rule__ScopeSpecification__Group__2__Impl
6464; 6464 rule__ScopeSpecification__Group__3
6465finally { 6465;
6466 restoreStackSize(stackSize); 6466finally {
6467} 6467 restoreStackSize(stackSize);
6468 6468}
6469rule__StringReference__Group__1__Impl 6469
6470 @init { 6470rule__ScopeSpecification__Group__2__Impl
6471 int stackSize = keepStackSize(); 6471 @init {
6472 } 6472 int stackSize = keepStackSize();
6473: 6473 }
6474( 6474:
6475 { before(grammarAccess.getStringReferenceAccess().getStringKeyword_1()); } 6475(
6476 'string' 6476 { before(grammarAccess.getScopeSpecificationAccess().getGroup_2()); }
6477 { after(grammarAccess.getStringReferenceAccess().getStringKeyword_1()); } 6477 (rule__ScopeSpecification__Group_2__0)?
6478) 6478 { after(grammarAccess.getScopeSpecificationAccess().getGroup_2()); }
6479; 6479)
6480finally { 6480;
6481 restoreStackSize(stackSize); 6481finally {
6482} 6482 restoreStackSize(stackSize);
6483 6483}
6484 6484
6485rule__IntervallNumber__Group__0 6485rule__ScopeSpecification__Group__3
6486 @init { 6486 @init {
6487 int stackSize = keepStackSize(); 6487 int stackSize = keepStackSize();
6488 } 6488 }
6489: 6489:
6490 rule__IntervallNumber__Group__0__Impl 6490 rule__ScopeSpecification__Group__3__Impl
6491 rule__IntervallNumber__Group__1 6491;
6492; 6492finally {
6493finally { 6493 restoreStackSize(stackSize);
6494 restoreStackSize(stackSize); 6494}
6495} 6495
6496 6496rule__ScopeSpecification__Group__3__Impl
6497rule__IntervallNumber__Group__0__Impl 6497 @init {
6498 @init { 6498 int stackSize = keepStackSize();
6499 int stackSize = keepStackSize(); 6499 }
6500 } 6500:
6501: 6501(
6502( 6502 { before(grammarAccess.getScopeSpecificationAccess().getRightCurlyBracketKeyword_3()); }
6503 { before(grammarAccess.getIntervallNumberAccess().getMinAssignment_0()); } 6503 '}'
6504 (rule__IntervallNumber__MinAssignment_0) 6504 { after(grammarAccess.getScopeSpecificationAccess().getRightCurlyBracketKeyword_3()); }
6505 { after(grammarAccess.getIntervallNumberAccess().getMinAssignment_0()); } 6505)
6506) 6506;
6507; 6507finally {
6508finally { 6508 restoreStackSize(stackSize);
6509 restoreStackSize(stackSize); 6509}
6510} 6510
6511 6511
6512rule__IntervallNumber__Group__1 6512rule__ScopeSpecification__Group_2__0
6513 @init { 6513 @init {
6514 int stackSize = keepStackSize(); 6514 int stackSize = keepStackSize();
6515 } 6515 }
6516: 6516:
6517 rule__IntervallNumber__Group__1__Impl 6517 rule__ScopeSpecification__Group_2__0__Impl
6518 rule__IntervallNumber__Group__2 6518 rule__ScopeSpecification__Group_2__1
6519; 6519;
6520finally { 6520finally {
6521 restoreStackSize(stackSize); 6521 restoreStackSize(stackSize);
6522} 6522}
6523 6523
6524rule__IntervallNumber__Group__1__Impl 6524rule__ScopeSpecification__Group_2__0__Impl
6525 @init { 6525 @init {
6526 int stackSize = keepStackSize(); 6526 int stackSize = keepStackSize();
6527 } 6527 }
6528: 6528:
6529( 6529(
6530 { before(grammarAccess.getIntervallNumberAccess().getFullStopFullStopKeyword_1()); } 6530 { before(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_0()); }
6531 '..' 6531 (rule__ScopeSpecification__ScopesAssignment_2_0)
6532 { after(grammarAccess.getIntervallNumberAccess().getFullStopFullStopKeyword_1()); } 6532 { after(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_0()); }
6533) 6533)
6534; 6534;
6535finally { 6535finally {
6536 restoreStackSize(stackSize); 6536 restoreStackSize(stackSize);
6537} 6537}
6538 6538
6539rule__IntervallNumber__Group__2 6539rule__ScopeSpecification__Group_2__1
6540 @init { 6540 @init {
6541 int stackSize = keepStackSize(); 6541 int stackSize = keepStackSize();
6542 } 6542 }
6543: 6543:
6544 rule__IntervallNumber__Group__2__Impl 6544 rule__ScopeSpecification__Group_2__1__Impl
6545; 6545;
6546finally { 6546finally {
6547 restoreStackSize(stackSize); 6547 restoreStackSize(stackSize);
6548} 6548}
6549 6549
6550rule__IntervallNumber__Group__2__Impl 6550rule__ScopeSpecification__Group_2__1__Impl
6551 @init { 6551 @init {
6552 int stackSize = keepStackSize(); 6552 int stackSize = keepStackSize();
6553 } 6553 }
6554: 6554:
6555( 6555(
6556 { before(grammarAccess.getIntervallNumberAccess().getAlternatives_2()); } 6556 { before(grammarAccess.getScopeSpecificationAccess().getGroup_2_1()); }
6557 (rule__IntervallNumber__Alternatives_2) 6557 (rule__ScopeSpecification__Group_2_1__0)*
6558 { after(grammarAccess.getIntervallNumberAccess().getAlternatives_2()); } 6558 { after(grammarAccess.getScopeSpecificationAccess().getGroup_2_1()); }
6559) 6559)
6560; 6560;
6561finally { 6561finally {
6562 restoreStackSize(stackSize); 6562 restoreStackSize(stackSize);
6563} 6563}
6564 6564
6565 6565
6566rule__IntEnumberation__Group__0 6566rule__ScopeSpecification__Group_2_1__0
6567 @init { 6567 @init {
6568 int stackSize = keepStackSize(); 6568 int stackSize = keepStackSize();
6569 } 6569 }
6570: 6570:
6571 rule__IntEnumberation__Group__0__Impl 6571 rule__ScopeSpecification__Group_2_1__0__Impl
6572 rule__IntEnumberation__Group__1 6572 rule__ScopeSpecification__Group_2_1__1
6573; 6573;
6574finally { 6574finally {
6575 restoreStackSize(stackSize); 6575 restoreStackSize(stackSize);
6576} 6576}
6577 6577
6578rule__IntEnumberation__Group__0__Impl 6578rule__ScopeSpecification__Group_2_1__0__Impl
6579 @init { 6579 @init {
6580 int stackSize = keepStackSize(); 6580 int stackSize = keepStackSize();
6581 } 6581 }
6582: 6582:
6583( 6583(
6584 { before(grammarAccess.getIntEnumberationAccess().getIntEnumberationAction_0()); } 6584 { before(grammarAccess.getScopeSpecificationAccess().getCommaKeyword_2_1_0()); }
6585 () 6585 ','
6586 { after(grammarAccess.getIntEnumberationAccess().getIntEnumberationAction_0()); } 6586 { after(grammarAccess.getScopeSpecificationAccess().getCommaKeyword_2_1_0()); }
6587) 6587)
6588; 6588;
6589finally { 6589finally {
6590 restoreStackSize(stackSize); 6590 restoreStackSize(stackSize);
6591} 6591}
6592 6592
6593rule__IntEnumberation__Group__1 6593rule__ScopeSpecification__Group_2_1__1
6594 @init { 6594 @init {
6595 int stackSize = keepStackSize(); 6595 int stackSize = keepStackSize();
6596 } 6596 }
6597: 6597:
6598 rule__IntEnumberation__Group__1__Impl 6598 rule__ScopeSpecification__Group_2_1__1__Impl
6599 rule__IntEnumberation__Group__2 6599;
6600; 6600finally {
6601finally { 6601 restoreStackSize(stackSize);
6602 restoreStackSize(stackSize); 6602}
6603} 6603
6604 6604rule__ScopeSpecification__Group_2_1__1__Impl
6605rule__IntEnumberation__Group__1__Impl 6605 @init {
6606 @init { 6606 int stackSize = keepStackSize();
6607 int stackSize = keepStackSize(); 6607 }
6608 } 6608:
6609: 6609(
6610( 6610 { before(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_1_1()); }
6611 { before(grammarAccess.getIntEnumberationAccess().getLeftCurlyBracketKeyword_1()); } 6611 (rule__ScopeSpecification__ScopesAssignment_2_1_1)
6612 '{' 6612 { after(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_1_1()); }
6613 { after(grammarAccess.getIntEnumberationAccess().getLeftCurlyBracketKeyword_1()); } 6613)
6614) 6614;
6615; 6615finally {
6616finally { 6616 restoreStackSize(stackSize);
6617 restoreStackSize(stackSize); 6617}
6618} 6618
6619 6619
6620rule__IntEnumberation__Group__2 6620rule__ClassTypeScope__Group__0
6621 @init { 6621 @init {
6622 int stackSize = keepStackSize(); 6622 int stackSize = keepStackSize();
6623 } 6623 }
6624: 6624:
6625 rule__IntEnumberation__Group__2__Impl 6625 rule__ClassTypeScope__Group__0__Impl
6626 rule__IntEnumberation__Group__3 6626 rule__ClassTypeScope__Group__1
6627; 6627;
6628finally { 6628finally {
6629 restoreStackSize(stackSize); 6629 restoreStackSize(stackSize);
6630} 6630}
6631 6631
6632rule__IntEnumberation__Group__2__Impl 6632rule__ClassTypeScope__Group__0__Impl
6633 @init { 6633 @init {
6634 int stackSize = keepStackSize(); 6634 int stackSize = keepStackSize();
6635 } 6635 }
6636: 6636:
6637( 6637(
6638 { before(grammarAccess.getIntEnumberationAccess().getGroup_2()); } 6638 { before(grammarAccess.getClassTypeScopeAccess().getNumberSignKeyword_0()); }
6639 (rule__IntEnumberation__Group_2__0)? 6639 '#'
6640 { after(grammarAccess.getIntEnumberationAccess().getGroup_2()); } 6640 { after(grammarAccess.getClassTypeScopeAccess().getNumberSignKeyword_0()); }
6641) 6641)
6642; 6642;
6643finally { 6643finally {
6644 restoreStackSize(stackSize); 6644 restoreStackSize(stackSize);
6645} 6645}
6646 6646
6647rule__IntEnumberation__Group__3 6647rule__ClassTypeScope__Group__1
6648 @init { 6648 @init {
6649 int stackSize = keepStackSize(); 6649 int stackSize = keepStackSize();
6650 } 6650 }
6651: 6651:
6652 rule__IntEnumberation__Group__3__Impl 6652 rule__ClassTypeScope__Group__1__Impl
6653; 6653 rule__ClassTypeScope__Group__2
6654finally { 6654;
6655 restoreStackSize(stackSize); 6655finally {
6656} 6656 restoreStackSize(stackSize);
6657 6657}
6658rule__IntEnumberation__Group__3__Impl 6658
6659 @init { 6659rule__ClassTypeScope__Group__1__Impl
6660 int stackSize = keepStackSize(); 6660 @init {
6661 } 6661 int stackSize = keepStackSize();
6662: 6662 }
6663( 6663:
6664 { before(grammarAccess.getIntEnumberationAccess().getRightCurlyBracketKeyword_3()); } 6664(
6665 '}' 6665 { before(grammarAccess.getClassTypeScopeAccess().getTypeAssignment_1()); }
6666 { after(grammarAccess.getIntEnumberationAccess().getRightCurlyBracketKeyword_3()); } 6666 (rule__ClassTypeScope__TypeAssignment_1)
6667) 6667 { after(grammarAccess.getClassTypeScopeAccess().getTypeAssignment_1()); }
6668; 6668)
6669finally { 6669;
6670 restoreStackSize(stackSize); 6670finally {
6671} 6671 restoreStackSize(stackSize);
6672 6672}
6673 6673
6674rule__IntEnumberation__Group_2__0 6674rule__ClassTypeScope__Group__2
6675 @init { 6675 @init {
6676 int stackSize = keepStackSize(); 6676 int stackSize = keepStackSize();
6677 } 6677 }
6678: 6678:
6679 rule__IntEnumberation__Group_2__0__Impl 6679 rule__ClassTypeScope__Group__2__Impl
6680 rule__IntEnumberation__Group_2__1 6680 rule__ClassTypeScope__Group__3
6681; 6681;
6682finally { 6682finally {
6683 restoreStackSize(stackSize); 6683 restoreStackSize(stackSize);
6684} 6684}
6685 6685
6686rule__IntEnumberation__Group_2__0__Impl 6686rule__ClassTypeScope__Group__2__Impl
6687 @init { 6687 @init {
6688 int stackSize = keepStackSize(); 6688 int stackSize = keepStackSize();
6689 } 6689 }
6690: 6690:
6691( 6691(
6692 { before(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_0()); } 6692 { before(grammarAccess.getClassTypeScopeAccess().getAlternatives_2()); }
6693 (rule__IntEnumberation__EntryAssignment_2_0) 6693 (rule__ClassTypeScope__Alternatives_2)
6694 { after(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_0()); } 6694 { after(grammarAccess.getClassTypeScopeAccess().getAlternatives_2()); }
6695) 6695)
6696; 6696;
6697finally { 6697finally {
6698 restoreStackSize(stackSize); 6698 restoreStackSize(stackSize);
6699} 6699}
6700 6700
6701rule__IntEnumberation__Group_2__1 6701rule__ClassTypeScope__Group__3
6702 @init { 6702 @init {
6703 int stackSize = keepStackSize(); 6703 int stackSize = keepStackSize();
6704 } 6704 }
6705: 6705:
6706 rule__IntEnumberation__Group_2__1__Impl 6706 rule__ClassTypeScope__Group__3__Impl
6707; 6707;
6708finally { 6708finally {
6709 restoreStackSize(stackSize); 6709 restoreStackSize(stackSize);
6710} 6710}
6711 6711
6712rule__IntEnumberation__Group_2__1__Impl 6712rule__ClassTypeScope__Group__3__Impl
6713 @init { 6713 @init {
6714 int stackSize = keepStackSize(); 6714 int stackSize = keepStackSize();
6715 } 6715 }
6716: 6716:
6717( 6717(
6718 { before(grammarAccess.getIntEnumberationAccess().getGroup_2_1()); } 6718 { before(grammarAccess.getClassTypeScopeAccess().getAlternatives_3()); }
6719 (rule__IntEnumberation__Group_2_1__0)* 6719 (rule__ClassTypeScope__Alternatives_3)
6720 { after(grammarAccess.getIntEnumberationAccess().getGroup_2_1()); } 6720 { after(grammarAccess.getClassTypeScopeAccess().getAlternatives_3()); }
6721) 6721)
6722; 6722;
6723finally { 6723finally {
6724 restoreStackSize(stackSize); 6724 restoreStackSize(stackSize);
6725} 6725}
6726 6726
6727 6727
6728rule__IntEnumberation__Group_2_1__0 6728rule__ObjectTypeScope__Group__0
6729 @init { 6729 @init {
6730 int stackSize = keepStackSize(); 6730 int stackSize = keepStackSize();
6731 } 6731 }
6732: 6732:
6733 rule__IntEnumberation__Group_2_1__0__Impl 6733 rule__ObjectTypeScope__Group__0__Impl
6734 rule__IntEnumberation__Group_2_1__1 6734 rule__ObjectTypeScope__Group__1
6735; 6735;
6736finally { 6736finally {
6737 restoreStackSize(stackSize); 6737 restoreStackSize(stackSize);
6738} 6738}
6739 6739
6740rule__IntEnumberation__Group_2_1__0__Impl 6740rule__ObjectTypeScope__Group__0__Impl
6741 @init { 6741 @init {
6742 int stackSize = keepStackSize(); 6742 int stackSize = keepStackSize();
6743 } 6743 }
6744: 6744:
6745( 6745(
6746 { before(grammarAccess.getIntEnumberationAccess().getCommaKeyword_2_1_0()); } 6746 { before(grammarAccess.getObjectTypeScopeAccess().getNumberSignKeyword_0()); }
6747 ',' 6747 '#'
6748 { after(grammarAccess.getIntEnumberationAccess().getCommaKeyword_2_1_0()); } 6748 { after(grammarAccess.getObjectTypeScopeAccess().getNumberSignKeyword_0()); }
6749) 6749)
6750; 6750;
6751finally { 6751finally {
6752 restoreStackSize(stackSize); 6752 restoreStackSize(stackSize);
6753} 6753}
6754 6754
6755rule__IntEnumberation__Group_2_1__1 6755rule__ObjectTypeScope__Group__1
6756 @init { 6756 @init {
6757 int stackSize = keepStackSize(); 6757 int stackSize = keepStackSize();
6758 } 6758 }
6759: 6759:
6760 rule__IntEnumberation__Group_2_1__1__Impl 6760 rule__ObjectTypeScope__Group__1__Impl
6761; 6761 rule__ObjectTypeScope__Group__2
6762finally { 6762;
6763 restoreStackSize(stackSize); 6763finally {
6764} 6764 restoreStackSize(stackSize);
6765 6765}
6766rule__IntEnumberation__Group_2_1__1__Impl 6766
6767 @init { 6767rule__ObjectTypeScope__Group__1__Impl
6768 int stackSize = keepStackSize(); 6768 @init {
6769 } 6769 int stackSize = keepStackSize();
6770: 6770 }
6771( 6771:
6772 { before(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_1_1()); } 6772(
6773 (rule__IntEnumberation__EntryAssignment_2_1_1) 6773 { before(grammarAccess.getObjectTypeScopeAccess().getTypeAssignment_1()); }
6774 { after(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_1_1()); } 6774 (rule__ObjectTypeScope__TypeAssignment_1)
6775) 6775 { after(grammarAccess.getObjectTypeScopeAccess().getTypeAssignment_1()); }
6776; 6776)
6777finally { 6777;
6778 restoreStackSize(stackSize); 6778finally {
6779} 6779 restoreStackSize(stackSize);
6780 6780}
6781 6781
6782rule__RealEnumeration__Group__0 6782rule__ObjectTypeScope__Group__2
6783 @init { 6783 @init {
6784 int stackSize = keepStackSize(); 6784 int stackSize = keepStackSize();
6785 } 6785 }
6786: 6786:
6787 rule__RealEnumeration__Group__0__Impl 6787 rule__ObjectTypeScope__Group__2__Impl
6788 rule__RealEnumeration__Group__1 6788 rule__ObjectTypeScope__Group__3
6789; 6789;
6790finally { 6790finally {
6791 restoreStackSize(stackSize); 6791 restoreStackSize(stackSize);
6792} 6792}
6793 6793
6794rule__RealEnumeration__Group__0__Impl 6794rule__ObjectTypeScope__Group__2__Impl
6795 @init { 6795 @init {
6796 int stackSize = keepStackSize(); 6796 int stackSize = keepStackSize();
6797 } 6797 }
6798: 6798:
6799( 6799(
6800 { before(grammarAccess.getRealEnumerationAccess().getRealEnumerationAction_0()); } 6800 { before(grammarAccess.getObjectTypeScopeAccess().getAlternatives_2()); }
6801 () 6801 (rule__ObjectTypeScope__Alternatives_2)
6802 { after(grammarAccess.getRealEnumerationAccess().getRealEnumerationAction_0()); } 6802 { after(grammarAccess.getObjectTypeScopeAccess().getAlternatives_2()); }
6803) 6803)
6804; 6804;
6805finally { 6805finally {
6806 restoreStackSize(stackSize); 6806 restoreStackSize(stackSize);
6807} 6807}
6808 6808
6809rule__RealEnumeration__Group__1 6809rule__ObjectTypeScope__Group__3
6810 @init { 6810 @init {
6811 int stackSize = keepStackSize(); 6811 int stackSize = keepStackSize();
6812 } 6812 }
6813: 6813:
6814 rule__RealEnumeration__Group__1__Impl 6814 rule__ObjectTypeScope__Group__3__Impl
6815 rule__RealEnumeration__Group__2 6815;
6816; 6816finally {
6817finally { 6817 restoreStackSize(stackSize);
6818 restoreStackSize(stackSize); 6818}
6819} 6819
6820 6820rule__ObjectTypeScope__Group__3__Impl
6821rule__RealEnumeration__Group__1__Impl 6821 @init {
6822 @init { 6822 int stackSize = keepStackSize();
6823 int stackSize = keepStackSize(); 6823 }
6824 } 6824:
6825: 6825(
6826( 6826 { before(grammarAccess.getObjectTypeScopeAccess().getAlternatives_3()); }
6827 { before(grammarAccess.getRealEnumerationAccess().getLeftCurlyBracketKeyword_1()); } 6827 (rule__ObjectTypeScope__Alternatives_3)
6828 '{' 6828 { after(grammarAccess.getObjectTypeScopeAccess().getAlternatives_3()); }
6829 { after(grammarAccess.getRealEnumerationAccess().getLeftCurlyBracketKeyword_1()); } 6829)
6830) 6830;
6831; 6831finally {
6832finally { 6832 restoreStackSize(stackSize);
6833 restoreStackSize(stackSize); 6833}
6834} 6834
6835 6835
6836rule__RealEnumeration__Group__2 6836rule__IntegerTypeScope__Group__0
6837 @init { 6837 @init {
6838 int stackSize = keepStackSize(); 6838 int stackSize = keepStackSize();
6839 } 6839 }
6840: 6840:
6841 rule__RealEnumeration__Group__2__Impl 6841 rule__IntegerTypeScope__Group__0__Impl
6842 rule__RealEnumeration__Group__3 6842 rule__IntegerTypeScope__Group__1
6843; 6843;
6844finally { 6844finally {
6845 restoreStackSize(stackSize); 6845 restoreStackSize(stackSize);
6846} 6846}
6847 6847
6848rule__RealEnumeration__Group__2__Impl 6848rule__IntegerTypeScope__Group__0__Impl
6849 @init { 6849 @init {
6850 int stackSize = keepStackSize(); 6850 int stackSize = keepStackSize();
6851 } 6851 }
6852: 6852:
6853( 6853(
6854 { before(grammarAccess.getRealEnumerationAccess().getGroup_2()); } 6854 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberSignKeyword_0()); }
6855 (rule__RealEnumeration__Group_2__0)? 6855 '#'
6856 { after(grammarAccess.getRealEnumerationAccess().getGroup_2()); } 6856 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberSignKeyword_0()); }
6857) 6857)
6858; 6858;
6859finally { 6859finally {
6860 restoreStackSize(stackSize); 6860 restoreStackSize(stackSize);
6861} 6861}
6862 6862
6863rule__RealEnumeration__Group__3 6863rule__IntegerTypeScope__Group__1
6864 @init { 6864 @init {
6865 int stackSize = keepStackSize(); 6865 int stackSize = keepStackSize();
6866 } 6866 }
6867: 6867:
6868 rule__RealEnumeration__Group__3__Impl 6868 rule__IntegerTypeScope__Group__1__Impl
6869; 6869 rule__IntegerTypeScope__Group__2
6870finally { 6870;
6871 restoreStackSize(stackSize); 6871finally {
6872} 6872 restoreStackSize(stackSize);
6873 6873}
6874rule__RealEnumeration__Group__3__Impl 6874
6875 @init { 6875rule__IntegerTypeScope__Group__1__Impl
6876 int stackSize = keepStackSize(); 6876 @init {
6877 } 6877 int stackSize = keepStackSize();
6878: 6878 }
6879( 6879:
6880 { before(grammarAccess.getRealEnumerationAccess().getRightCurlyBracketKeyword_3()); } 6880(
6881 '}' 6881 { before(grammarAccess.getIntegerTypeScopeAccess().getTypeAssignment_1()); }
6882 { after(grammarAccess.getRealEnumerationAccess().getRightCurlyBracketKeyword_3()); } 6882 (rule__IntegerTypeScope__TypeAssignment_1)
6883) 6883 { after(grammarAccess.getIntegerTypeScopeAccess().getTypeAssignment_1()); }
6884; 6884)
6885finally { 6885;
6886 restoreStackSize(stackSize); 6886finally {
6887} 6887 restoreStackSize(stackSize);
6888 6888}
6889 6889
6890rule__RealEnumeration__Group_2__0 6890rule__IntegerTypeScope__Group__2
6891 @init { 6891 @init {
6892 int stackSize = keepStackSize(); 6892 int stackSize = keepStackSize();
6893 } 6893 }
6894: 6894:
6895 rule__RealEnumeration__Group_2__0__Impl 6895 rule__IntegerTypeScope__Group__2__Impl
6896 rule__RealEnumeration__Group_2__1 6896 rule__IntegerTypeScope__Group__3
6897; 6897;
6898finally { 6898finally {
6899 restoreStackSize(stackSize); 6899 restoreStackSize(stackSize);
6900} 6900}
6901 6901
6902rule__RealEnumeration__Group_2__0__Impl 6902rule__IntegerTypeScope__Group__2__Impl
6903 @init { 6903 @init {
6904 int stackSize = keepStackSize(); 6904 int stackSize = keepStackSize();
6905 } 6905 }
6906: 6906:
6907( 6907(
6908 { before(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_0()); } 6908 { before(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_2()); }
6909 (rule__RealEnumeration__EntryAssignment_2_0) 6909 (rule__IntegerTypeScope__Alternatives_2)
6910 { after(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_0()); } 6910 { after(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_2()); }
6911) 6911)
6912; 6912;
6913finally { 6913finally {
6914 restoreStackSize(stackSize); 6914 restoreStackSize(stackSize);
6915} 6915}
6916 6916
6917rule__RealEnumeration__Group_2__1 6917rule__IntegerTypeScope__Group__3
6918 @init { 6918 @init {
6919 int stackSize = keepStackSize(); 6919 int stackSize = keepStackSize();
6920 } 6920 }
6921: 6921:
6922 rule__RealEnumeration__Group_2__1__Impl 6922 rule__IntegerTypeScope__Group__3__Impl
6923; 6923;
6924finally { 6924finally {
6925 restoreStackSize(stackSize); 6925 restoreStackSize(stackSize);
6926} 6926}
6927 6927
6928rule__RealEnumeration__Group_2__1__Impl 6928rule__IntegerTypeScope__Group__3__Impl
6929 @init { 6929 @init {
6930 int stackSize = keepStackSize(); 6930 int stackSize = keepStackSize();
6931 } 6931 }
6932: 6932:
6933( 6933(
6934 { before(grammarAccess.getRealEnumerationAccess().getGroup_2_1()); } 6934 { before(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_3()); }
6935 (rule__RealEnumeration__Group_2_1__0)* 6935 (rule__IntegerTypeScope__Alternatives_3)
6936 { after(grammarAccess.getRealEnumerationAccess().getGroup_2_1()); } 6936 { after(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_3()); }
6937) 6937)
6938; 6938;
6939finally { 6939finally {
6940 restoreStackSize(stackSize); 6940 restoreStackSize(stackSize);
6941} 6941}
6942 6942
6943 6943
6944rule__RealEnumeration__Group_2_1__0 6944rule__RealTypeScope__Group__0
6945 @init { 6945 @init {
6946 int stackSize = keepStackSize(); 6946 int stackSize = keepStackSize();
6947 } 6947 }
6948: 6948:
6949 rule__RealEnumeration__Group_2_1__0__Impl 6949 rule__RealTypeScope__Group__0__Impl
6950 rule__RealEnumeration__Group_2_1__1 6950 rule__RealTypeScope__Group__1
6951; 6951;
6952finally { 6952finally {
6953 restoreStackSize(stackSize); 6953 restoreStackSize(stackSize);
6954} 6954}
6955 6955
6956rule__RealEnumeration__Group_2_1__0__Impl 6956rule__RealTypeScope__Group__0__Impl
6957 @init { 6957 @init {
6958 int stackSize = keepStackSize(); 6958 int stackSize = keepStackSize();
6959 } 6959 }
6960: 6960:
6961( 6961(
6962 { before(grammarAccess.getRealEnumerationAccess().getCommaKeyword_2_1_0()); } 6962 { before(grammarAccess.getRealTypeScopeAccess().getNumberSignKeyword_0()); }
6963 ',' 6963 '#'
6964 { after(grammarAccess.getRealEnumerationAccess().getCommaKeyword_2_1_0()); } 6964 { after(grammarAccess.getRealTypeScopeAccess().getNumberSignKeyword_0()); }
6965) 6965)
6966; 6966;
6967finally { 6967finally {
6968 restoreStackSize(stackSize); 6968 restoreStackSize(stackSize);
6969} 6969}
6970 6970
6971rule__RealEnumeration__Group_2_1__1 6971rule__RealTypeScope__Group__1
6972 @init { 6972 @init {
6973 int stackSize = keepStackSize(); 6973 int stackSize = keepStackSize();
6974 } 6974 }
6975: 6975:
6976 rule__RealEnumeration__Group_2_1__1__Impl 6976 rule__RealTypeScope__Group__1__Impl
6977; 6977 rule__RealTypeScope__Group__2
6978finally { 6978;
6979 restoreStackSize(stackSize); 6979finally {
6980} 6980 restoreStackSize(stackSize);
6981 6981}
6982rule__RealEnumeration__Group_2_1__1__Impl 6982
6983 @init { 6983rule__RealTypeScope__Group__1__Impl
6984 int stackSize = keepStackSize(); 6984 @init {
6985 } 6985 int stackSize = keepStackSize();
6986: 6986 }
6987( 6987:
6988 { before(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_1_1()); } 6988(
6989 (rule__RealEnumeration__EntryAssignment_2_1_1) 6989 { before(grammarAccess.getRealTypeScopeAccess().getTypeAssignment_1()); }
6990 { after(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_1_1()); } 6990 (rule__RealTypeScope__TypeAssignment_1)
6991) 6991 { after(grammarAccess.getRealTypeScopeAccess().getTypeAssignment_1()); }
6992; 6992)
6993finally { 6993;
6994 restoreStackSize(stackSize); 6994finally {
6995} 6995 restoreStackSize(stackSize);
6996 6996}
6997 6997
6998rule__StringEnumeration__Group__0 6998rule__RealTypeScope__Group__2
6999 @init { 6999 @init {
7000 int stackSize = keepStackSize(); 7000 int stackSize = keepStackSize();
7001 } 7001 }
7002: 7002:
7003 rule__StringEnumeration__Group__0__Impl 7003 rule__RealTypeScope__Group__2__Impl
7004 rule__StringEnumeration__Group__1 7004 rule__RealTypeScope__Group__3
7005; 7005;
7006finally { 7006finally {
7007 restoreStackSize(stackSize); 7007 restoreStackSize(stackSize);
7008} 7008}
7009 7009
7010rule__StringEnumeration__Group__0__Impl 7010rule__RealTypeScope__Group__2__Impl
7011 @init { 7011 @init {
7012 int stackSize = keepStackSize(); 7012 int stackSize = keepStackSize();
7013 } 7013 }
7014: 7014:
7015( 7015(
7016 { before(grammarAccess.getStringEnumerationAccess().getStringEnumerationAction_0()); } 7016 { before(grammarAccess.getRealTypeScopeAccess().getAlternatives_2()); }
7017 () 7017 (rule__RealTypeScope__Alternatives_2)
7018 { after(grammarAccess.getStringEnumerationAccess().getStringEnumerationAction_0()); } 7018 { after(grammarAccess.getRealTypeScopeAccess().getAlternatives_2()); }
7019) 7019)
7020; 7020;
7021finally { 7021finally {
7022 restoreStackSize(stackSize); 7022 restoreStackSize(stackSize);
7023} 7023}
7024 7024
7025rule__StringEnumeration__Group__1 7025rule__RealTypeScope__Group__3
7026 @init { 7026 @init {
7027 int stackSize = keepStackSize(); 7027 int stackSize = keepStackSize();
7028 } 7028 }
7029: 7029:
7030 rule__StringEnumeration__Group__1__Impl 7030 rule__RealTypeScope__Group__3__Impl
7031 rule__StringEnumeration__Group__2 7031;
7032; 7032finally {
7033finally { 7033 restoreStackSize(stackSize);
7034 restoreStackSize(stackSize); 7034}
7035} 7035
7036 7036rule__RealTypeScope__Group__3__Impl
7037rule__StringEnumeration__Group__1__Impl 7037 @init {
7038 @init { 7038 int stackSize = keepStackSize();
7039 int stackSize = keepStackSize(); 7039 }
7040 } 7040:
7041: 7041(
7042( 7042 { before(grammarAccess.getRealTypeScopeAccess().getAlternatives_3()); }
7043 { before(grammarAccess.getStringEnumerationAccess().getLeftCurlyBracketKeyword_1()); } 7043 (rule__RealTypeScope__Alternatives_3)
7044 '{' 7044 { after(grammarAccess.getRealTypeScopeAccess().getAlternatives_3()); }
7045 { after(grammarAccess.getStringEnumerationAccess().getLeftCurlyBracketKeyword_1()); } 7045)
7046) 7046;
7047; 7047finally {
7048finally { 7048 restoreStackSize(stackSize);
7049 restoreStackSize(stackSize); 7049}
7050} 7050
7051 7051
7052rule__StringEnumeration__Group__2 7052rule__StringTypeScope__Group__0
7053 @init { 7053 @init {
7054 int stackSize = keepStackSize(); 7054 int stackSize = keepStackSize();
7055 } 7055 }
7056: 7056:
7057 rule__StringEnumeration__Group__2__Impl 7057 rule__StringTypeScope__Group__0__Impl
7058 rule__StringEnumeration__Group__3 7058 rule__StringTypeScope__Group__1
7059; 7059;
7060finally { 7060finally {
7061 restoreStackSize(stackSize); 7061 restoreStackSize(stackSize);
7062} 7062}
7063 7063
7064rule__StringEnumeration__Group__2__Impl 7064rule__StringTypeScope__Group__0__Impl
7065 @init { 7065 @init {
7066 int stackSize = keepStackSize(); 7066 int stackSize = keepStackSize();
7067 } 7067 }
7068: 7068:
7069( 7069(
7070 { before(grammarAccess.getStringEnumerationAccess().getGroup_2()); } 7070 { before(grammarAccess.getStringTypeScopeAccess().getNumberSignKeyword_0()); }
7071 (rule__StringEnumeration__Group_2__0)? 7071 '#'
7072 { after(grammarAccess.getStringEnumerationAccess().getGroup_2()); } 7072 { after(grammarAccess.getStringTypeScopeAccess().getNumberSignKeyword_0()); }
7073) 7073)
7074; 7074;
7075finally { 7075finally {
7076 restoreStackSize(stackSize); 7076 restoreStackSize(stackSize);
7077} 7077}
7078 7078
7079rule__StringEnumeration__Group__3 7079rule__StringTypeScope__Group__1
7080 @init { 7080 @init {
7081 int stackSize = keepStackSize(); 7081 int stackSize = keepStackSize();
7082 } 7082 }
7083: 7083:
7084 rule__StringEnumeration__Group__3__Impl 7084 rule__StringTypeScope__Group__1__Impl
7085; 7085 rule__StringTypeScope__Group__2
7086finally { 7086;
7087 restoreStackSize(stackSize); 7087finally {
7088} 7088 restoreStackSize(stackSize);
7089 7089}
7090rule__StringEnumeration__Group__3__Impl 7090
7091 @init { 7091rule__StringTypeScope__Group__1__Impl
7092 int stackSize = keepStackSize(); 7092 @init {
7093 } 7093 int stackSize = keepStackSize();
7094: 7094 }
7095( 7095:
7096 { before(grammarAccess.getStringEnumerationAccess().getRightCurlyBracketKeyword_3()); } 7096(
7097 '}' 7097 { before(grammarAccess.getStringTypeScopeAccess().getTypeAssignment_1()); }
7098 { after(grammarAccess.getStringEnumerationAccess().getRightCurlyBracketKeyword_3()); } 7098 (rule__StringTypeScope__TypeAssignment_1)
7099) 7099 { after(grammarAccess.getStringTypeScopeAccess().getTypeAssignment_1()); }
7100; 7100)
7101finally { 7101;
7102 restoreStackSize(stackSize); 7102finally {
7103} 7103 restoreStackSize(stackSize);
7104 7104}
7105 7105
7106rule__StringEnumeration__Group_2__0 7106rule__StringTypeScope__Group__2
7107 @init { 7107 @init {
7108 int stackSize = keepStackSize(); 7108 int stackSize = keepStackSize();
7109 } 7109 }
7110: 7110:
7111 rule__StringEnumeration__Group_2__0__Impl 7111 rule__StringTypeScope__Group__2__Impl
7112 rule__StringEnumeration__Group_2__1 7112 rule__StringTypeScope__Group__3
7113; 7113;
7114finally { 7114finally {
7115 restoreStackSize(stackSize); 7115 restoreStackSize(stackSize);
7116} 7116}
7117 7117
7118rule__StringEnumeration__Group_2__0__Impl 7118rule__StringTypeScope__Group__2__Impl
7119 @init { 7119 @init {
7120 int stackSize = keepStackSize(); 7120 int stackSize = keepStackSize();
7121 } 7121 }
7122: 7122:
7123( 7123(
7124 { before(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_0()); } 7124 { before(grammarAccess.getStringTypeScopeAccess().getAlternatives_2()); }
7125 (rule__StringEnumeration__EntryAssignment_2_0) 7125 (rule__StringTypeScope__Alternatives_2)
7126 { after(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_0()); } 7126 { after(grammarAccess.getStringTypeScopeAccess().getAlternatives_2()); }
7127) 7127)
7128; 7128;
7129finally { 7129finally {
7130 restoreStackSize(stackSize); 7130 restoreStackSize(stackSize);
7131} 7131}
7132 7132
7133rule__StringEnumeration__Group_2__1 7133rule__StringTypeScope__Group__3
7134 @init { 7134 @init {
7135 int stackSize = keepStackSize(); 7135 int stackSize = keepStackSize();
7136 } 7136 }
7137: 7137:
7138 rule__StringEnumeration__Group_2__1__Impl 7138 rule__StringTypeScope__Group__3__Impl
7139; 7139;
7140finally { 7140finally {
7141 restoreStackSize(stackSize); 7141 restoreStackSize(stackSize);
7142} 7142}
7143 7143
7144rule__StringEnumeration__Group_2__1__Impl 7144rule__StringTypeScope__Group__3__Impl
7145 @init { 7145 @init {
7146 int stackSize = keepStackSize(); 7146 int stackSize = keepStackSize();
7147 } 7147 }
7148: 7148:
7149( 7149(
7150 { before(grammarAccess.getStringEnumerationAccess().getGroup_2_1()); } 7150 { before(grammarAccess.getStringTypeScopeAccess().getAlternatives_3()); }
7151 (rule__StringEnumeration__Group_2_1__0)* 7151 (rule__StringTypeScope__Alternatives_3)
7152 { after(grammarAccess.getStringEnumerationAccess().getGroup_2_1()); } 7152 { after(grammarAccess.getStringTypeScopeAccess().getAlternatives_3()); }
7153) 7153)
7154; 7154;
7155finally { 7155finally {
7156 restoreStackSize(stackSize); 7156 restoreStackSize(stackSize);
7157} 7157}
7158 7158
7159 7159
7160rule__StringEnumeration__Group_2_1__0 7160rule__ClassReference__Group__0
7161 @init { 7161 @init {
7162 int stackSize = keepStackSize(); 7162 int stackSize = keepStackSize();
7163 } 7163 }
7164: 7164:
7165 rule__StringEnumeration__Group_2_1__0__Impl 7165 rule__ClassReference__Group__0__Impl
7166 rule__StringEnumeration__Group_2_1__1 7166 rule__ClassReference__Group__1
7167; 7167;
7168finally { 7168finally {
7169 restoreStackSize(stackSize); 7169 restoreStackSize(stackSize);
7170} 7170}
7171 7171
7172rule__StringEnumeration__Group_2_1__0__Impl 7172rule__ClassReference__Group__0__Impl
7173 @init { 7173 @init {
7174 int stackSize = keepStackSize(); 7174 int stackSize = keepStackSize();
7175 } 7175 }
7176: 7176:
7177( 7177(
7178 { before(grammarAccess.getStringEnumerationAccess().getCommaKeyword_2_1_0()); } 7178 { before(grammarAccess.getClassReferenceAccess().getLessThanSignKeyword_0()); }
7179 ',' 7179 '<'
7180 { after(grammarAccess.getStringEnumerationAccess().getCommaKeyword_2_1_0()); } 7180 { after(grammarAccess.getClassReferenceAccess().getLessThanSignKeyword_0()); }
7181) 7181)
7182; 7182;
7183finally { 7183finally {
7184 restoreStackSize(stackSize); 7184 restoreStackSize(stackSize);
7185} 7185}
7186 7186
7187rule__StringEnumeration__Group_2_1__1 7187rule__ClassReference__Group__1
7188 @init { 7188 @init {
7189 int stackSize = keepStackSize(); 7189 int stackSize = keepStackSize();
7190 } 7190 }
7191: 7191:
7192 rule__StringEnumeration__Group_2_1__1__Impl 7192 rule__ClassReference__Group__1__Impl
7193; 7193 rule__ClassReference__Group__2
7194finally { 7194;
7195 restoreStackSize(stackSize); 7195finally {
7196} 7196 restoreStackSize(stackSize);
7197 7197}
7198rule__StringEnumeration__Group_2_1__1__Impl 7198
7199 @init { 7199rule__ClassReference__Group__1__Impl
7200 int stackSize = keepStackSize(); 7200 @init {
7201 } 7201 int stackSize = keepStackSize();
7202: 7202 }
7203( 7203:
7204 { before(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_1_1()); } 7204(
7205 (rule__StringEnumeration__EntryAssignment_2_1_1) 7205 { before(grammarAccess.getClassReferenceAccess().getElementAssignment_1()); }
7206 { after(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_1_1()); } 7206 (rule__ClassReference__ElementAssignment_1)
7207) 7207 { after(grammarAccess.getClassReferenceAccess().getElementAssignment_1()); }
7208; 7208)
7209finally { 7209;
7210 restoreStackSize(stackSize); 7210finally {
7211} 7211 restoreStackSize(stackSize);
7212 7212}
7213 7213
7214rule__ScopeDeclaration__Group__0 7214rule__ClassReference__Group__2
7215 @init { 7215 @init {
7216 int stackSize = keepStackSize(); 7216 int stackSize = keepStackSize();
7217 } 7217 }
7218: 7218:
7219 rule__ScopeDeclaration__Group__0__Impl 7219 rule__ClassReference__Group__2__Impl
7220 rule__ScopeDeclaration__Group__1 7220;
7221; 7221finally {
7222finally { 7222 restoreStackSize(stackSize);
7223 restoreStackSize(stackSize); 7223}
7224} 7224
7225 7225rule__ClassReference__Group__2__Impl
7226rule__ScopeDeclaration__Group__0__Impl 7226 @init {
7227 @init { 7227 int stackSize = keepStackSize();
7228 int stackSize = keepStackSize(); 7228 }
7229 } 7229:
7230: 7230(
7231( 7231 { before(grammarAccess.getClassReferenceAccess().getGreaterThanSignKeyword_2()); }
7232 { before(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); } 7232 '>'
7233 'scope' 7233 { after(grammarAccess.getClassReferenceAccess().getGreaterThanSignKeyword_2()); }
7234 { after(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); } 7234)
7235) 7235;
7236; 7236finally {
7237finally { 7237 restoreStackSize(stackSize);
7238 restoreStackSize(stackSize); 7238}
7239} 7239
7240 7240
7241rule__ScopeDeclaration__Group__1 7241rule__ObjectReference__Group__0
7242 @init { 7242 @init {
7243 int stackSize = keepStackSize(); 7243 int stackSize = keepStackSize();
7244 } 7244 }
7245: 7245:
7246 rule__ScopeDeclaration__Group__1__Impl 7246 rule__ObjectReference__Group__0__Impl
7247 rule__ScopeDeclaration__Group__2 7247 rule__ObjectReference__Group__1
7248; 7248;
7249finally { 7249finally {
7250 restoreStackSize(stackSize); 7250 restoreStackSize(stackSize);
7251} 7251}
7252 7252
7253rule__ScopeDeclaration__Group__1__Impl 7253rule__ObjectReference__Group__0__Impl
7254 @init { 7254 @init {
7255 int stackSize = keepStackSize(); 7255 int stackSize = keepStackSize();
7256 } 7256 }
7257: 7257:
7258( 7258(
7259 { before(grammarAccess.getScopeDeclarationAccess().getNameAssignment_1()); } 7259 { before(grammarAccess.getObjectReferenceAccess().getObjectReferenceAction_0()); }
7260 (rule__ScopeDeclaration__NameAssignment_1) 7260 ()
7261 { after(grammarAccess.getScopeDeclarationAccess().getNameAssignment_1()); } 7261 { after(grammarAccess.getObjectReferenceAccess().getObjectReferenceAction_0()); }
7262) 7262)
7263; 7263;
7264finally { 7264finally {
7265 restoreStackSize(stackSize); 7265 restoreStackSize(stackSize);
7266} 7266}
7267 7267
7268rule__ScopeDeclaration__Group__2 7268rule__ObjectReference__Group__1
7269 @init { 7269 @init {
7270 int stackSize = keepStackSize(); 7270 int stackSize = keepStackSize();
7271 } 7271 }
7272: 7272:
7273 rule__ScopeDeclaration__Group__2__Impl 7273 rule__ObjectReference__Group__1__Impl
7274; 7274;
7275finally { 7275finally {
7276 restoreStackSize(stackSize); 7276 restoreStackSize(stackSize);
7277} 7277}
7278 7278
7279rule__ScopeDeclaration__Group__2__Impl 7279rule__ObjectReference__Group__1__Impl
7280 @init { 7280 @init {
7281 int stackSize = keepStackSize(); 7281 int stackSize = keepStackSize();
7282 } 7282 }
7283: 7283:
7284( 7284(
7285 { before(grammarAccess.getScopeDeclarationAccess().getSpecificationAssignment_2()); } 7285 { before(grammarAccess.getObjectReferenceAccess().getNodeKeyword_1()); }
7286 (rule__ScopeDeclaration__SpecificationAssignment_2) 7286 'node'
7287 { after(grammarAccess.getScopeDeclarationAccess().getSpecificationAssignment_2()); } 7287 { after(grammarAccess.getObjectReferenceAccess().getNodeKeyword_1()); }
7288) 7288)
7289; 7289;
7290finally { 7290finally {
7291 restoreStackSize(stackSize); 7291 restoreStackSize(stackSize);
7292} 7292}
7293 7293
7294 7294
7295rule__GenerationTask__Group__0 7295rule__IntegerReference__Group__0
7296 @init { 7296 @init {
7297 int stackSize = keepStackSize(); 7297 int stackSize = keepStackSize();
7298 } 7298 }
7299: 7299:
7300 rule__GenerationTask__Group__0__Impl 7300 rule__IntegerReference__Group__0__Impl
7301 rule__GenerationTask__Group__1 7301 rule__IntegerReference__Group__1
7302; 7302;
7303finally { 7303finally {
7304 restoreStackSize(stackSize); 7304 restoreStackSize(stackSize);
7305} 7305}
7306 7306
7307rule__GenerationTask__Group__0__Impl 7307rule__IntegerReference__Group__0__Impl
7308 @init { 7308 @init {
7309 int stackSize = keepStackSize(); 7309 int stackSize = keepStackSize();
7310 } 7310 }
7311: 7311:
7312( 7312(
7313 { before(grammarAccess.getGenerationTaskAccess().getGenerateKeyword_0()); } 7313 { before(grammarAccess.getIntegerReferenceAccess().getIntegerScopeAction_0()); }
7314 'generate' 7314 ()
7315 { after(grammarAccess.getGenerationTaskAccess().getGenerateKeyword_0()); } 7315 { after(grammarAccess.getIntegerReferenceAccess().getIntegerScopeAction_0()); }
7316) 7316)
7317; 7317;
7318finally { 7318finally {
7319 restoreStackSize(stackSize); 7319 restoreStackSize(stackSize);
7320} 7320}
7321 7321
7322rule__GenerationTask__Group__1 7322rule__IntegerReference__Group__1
7323 @init { 7323 @init {
7324 int stackSize = keepStackSize(); 7324 int stackSize = keepStackSize();
7325 } 7325 }
7326: 7326:
7327 rule__GenerationTask__Group__1__Impl 7327 rule__IntegerReference__Group__1__Impl
7328 rule__GenerationTask__Group__2 7328;
7329; 7329finally {
7330finally { 7330 restoreStackSize(stackSize);
7331 restoreStackSize(stackSize); 7331}
7332} 7332
7333 7333rule__IntegerReference__Group__1__Impl
7334rule__GenerationTask__Group__1__Impl 7334 @init {
7335 @init { 7335 int stackSize = keepStackSize();
7336 int stackSize = keepStackSize(); 7336 }
7337 } 7337:
7338: 7338(
7339( 7339 { before(grammarAccess.getIntegerReferenceAccess().getIntKeyword_1()); }
7340 { before(grammarAccess.getGenerationTaskAccess().getGenerationTaskAction_1()); } 7340 'int'
7341 () 7341 { after(grammarAccess.getIntegerReferenceAccess().getIntKeyword_1()); }
7342 { after(grammarAccess.getGenerationTaskAccess().getGenerationTaskAction_1()); } 7342)
7343) 7343;
7344; 7344finally {
7345finally { 7345 restoreStackSize(stackSize);
7346 restoreStackSize(stackSize); 7346}
7347} 7347
7348 7348
7349rule__GenerationTask__Group__2 7349rule__RealReference__Group__0
7350 @init { 7350 @init {
7351 int stackSize = keepStackSize(); 7351 int stackSize = keepStackSize();
7352 } 7352 }
7353: 7353:
7354 rule__GenerationTask__Group__2__Impl 7354 rule__RealReference__Group__0__Impl
7355 rule__GenerationTask__Group__3 7355 rule__RealReference__Group__1
7356; 7356;
7357finally { 7357finally {
7358 restoreStackSize(stackSize); 7358 restoreStackSize(stackSize);
7359} 7359}
7360 7360
7361rule__GenerationTask__Group__2__Impl 7361rule__RealReference__Group__0__Impl
7362 @init { 7362 @init {
7363 int stackSize = keepStackSize(); 7363 int stackSize = keepStackSize();
7364 } 7364 }
7365: 7365:
7366( 7366(
7367 { before(grammarAccess.getGenerationTaskAccess().getLeftCurlyBracketKeyword_2()); } 7367 { before(grammarAccess.getRealReferenceAccess().getRealScopeAction_0()); }
7368 '{' 7368 ()
7369 { after(grammarAccess.getGenerationTaskAccess().getLeftCurlyBracketKeyword_2()); } 7369 { after(grammarAccess.getRealReferenceAccess().getRealScopeAction_0()); }
7370) 7370)
7371; 7371;
7372finally { 7372finally {
7373 restoreStackSize(stackSize); 7373 restoreStackSize(stackSize);
7374} 7374}
7375 7375
7376rule__GenerationTask__Group__3 7376rule__RealReference__Group__1
7377 @init { 7377 @init {
7378 int stackSize = keepStackSize(); 7378 int stackSize = keepStackSize();
7379 } 7379 }
7380: 7380:
7381 rule__GenerationTask__Group__3__Impl 7381 rule__RealReference__Group__1__Impl
7382 rule__GenerationTask__Group__4 7382;
7383; 7383finally {
7384finally { 7384 restoreStackSize(stackSize);
7385 restoreStackSize(stackSize); 7385}
7386} 7386
7387 7387rule__RealReference__Group__1__Impl
7388rule__GenerationTask__Group__3__Impl 7388 @init {
7389 @init { 7389 int stackSize = keepStackSize();
7390 int stackSize = keepStackSize(); 7390 }
7391 } 7391:
7392: 7392(
7393( 7393 { before(grammarAccess.getRealReferenceAccess().getRealKeyword_1()); }
7394 { before(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); } 7394 'real'
7395 (rule__GenerationTask__UnorderedGroup_3) 7395 { after(grammarAccess.getRealReferenceAccess().getRealKeyword_1()); }
7396 { after(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); } 7396)
7397) 7397;
7398; 7398finally {
7399finally { 7399 restoreStackSize(stackSize);
7400 restoreStackSize(stackSize); 7400}
7401} 7401
7402 7402
7403rule__GenerationTask__Group__4 7403rule__StringReference__Group__0
7404 @init { 7404 @init {
7405 int stackSize = keepStackSize(); 7405 int stackSize = keepStackSize();
7406 } 7406 }
7407: 7407:
7408 rule__GenerationTask__Group__4__Impl 7408 rule__StringReference__Group__0__Impl
7409; 7409 rule__StringReference__Group__1
7410finally { 7410;
7411 restoreStackSize(stackSize); 7411finally {
7412} 7412 restoreStackSize(stackSize);
7413 7413}
7414rule__GenerationTask__Group__4__Impl 7414
7415 @init { 7415rule__StringReference__Group__0__Impl
7416 int stackSize = keepStackSize(); 7416 @init {
7417 } 7417 int stackSize = keepStackSize();
7418: 7418 }
7419( 7419:
7420 { before(grammarAccess.getGenerationTaskAccess().getRightCurlyBracketKeyword_4()); } 7420(
7421 '}' 7421 { before(grammarAccess.getStringReferenceAccess().getStringScopeAction_0()); }
7422 { after(grammarAccess.getGenerationTaskAccess().getRightCurlyBracketKeyword_4()); } 7422 ()
7423) 7423 { after(grammarAccess.getStringReferenceAccess().getStringScopeAction_0()); }
7424; 7424)
7425finally { 7425;
7426 restoreStackSize(stackSize); 7426finally {
7427} 7427 restoreStackSize(stackSize);
7428 7428}
7429 7429
7430rule__GenerationTask__Group_3_0__0 7430rule__StringReference__Group__1
7431 @init { 7431 @init {
7432 int stackSize = keepStackSize(); 7432 int stackSize = keepStackSize();
7433 } 7433 }
7434: 7434:
7435 rule__GenerationTask__Group_3_0__0__Impl 7435 rule__StringReference__Group__1__Impl
7436 rule__GenerationTask__Group_3_0__1 7436;
7437; 7437finally {
7438finally { 7438 restoreStackSize(stackSize);
7439 restoreStackSize(stackSize); 7439}
7440} 7440
7441 7441rule__StringReference__Group__1__Impl
7442rule__GenerationTask__Group_3_0__0__Impl 7442 @init {
7443 @init { 7443 int stackSize = keepStackSize();
7444 int stackSize = keepStackSize(); 7444 }
7445 } 7445:
7446: 7446(
7447( 7447 { before(grammarAccess.getStringReferenceAccess().getStringKeyword_1()); }
7448 { before(grammarAccess.getGenerationTaskAccess().getMetamodelKeyword_3_0_0()); } 7448 'string'
7449 'metamodel' 7449 { after(grammarAccess.getStringReferenceAccess().getStringKeyword_1()); }
7450 { after(grammarAccess.getGenerationTaskAccess().getMetamodelKeyword_3_0_0()); } 7450)
7451) 7451;
7452; 7452finally {
7453finally { 7453 restoreStackSize(stackSize);
7454 restoreStackSize(stackSize); 7454}
7455} 7455
7456 7456
7457rule__GenerationTask__Group_3_0__1 7457rule__IntervallNumber__Group__0
7458 @init { 7458 @init {
7459 int stackSize = keepStackSize(); 7459 int stackSize = keepStackSize();
7460 } 7460 }
7461: 7461:
7462 rule__GenerationTask__Group_3_0__1__Impl 7462 rule__IntervallNumber__Group__0__Impl
7463 rule__GenerationTask__Group_3_0__2 7463 rule__IntervallNumber__Group__1
7464; 7464;
7465finally { 7465finally {
7466 restoreStackSize(stackSize); 7466 restoreStackSize(stackSize);
7467} 7467}
7468 7468
7469rule__GenerationTask__Group_3_0__1__Impl 7469rule__IntervallNumber__Group__0__Impl
7470 @init { 7470 @init {
7471 int stackSize = keepStackSize(); 7471 int stackSize = keepStackSize();
7472 } 7472 }
7473: 7473:
7474( 7474(
7475 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_0_1()); } 7475 { before(grammarAccess.getIntervallNumberAccess().getMinAssignment_0()); }
7476 '=' 7476 (rule__IntervallNumber__MinAssignment_0)
7477 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_0_1()); } 7477 { after(grammarAccess.getIntervallNumberAccess().getMinAssignment_0()); }
7478) 7478)
7479; 7479;
7480finally { 7480finally {
7481 restoreStackSize(stackSize); 7481 restoreStackSize(stackSize);
7482} 7482}
7483 7483
7484rule__GenerationTask__Group_3_0__2 7484rule__IntervallNumber__Group__1
7485 @init { 7485 @init {
7486 int stackSize = keepStackSize(); 7486 int stackSize = keepStackSize();
7487 } 7487 }
7488: 7488:
7489 rule__GenerationTask__Group_3_0__2__Impl 7489 rule__IntervallNumber__Group__1__Impl
7490; 7490 rule__IntervallNumber__Group__2
7491finally { 7491;
7492 restoreStackSize(stackSize); 7492finally {
7493} 7493 restoreStackSize(stackSize);
7494 7494}
7495rule__GenerationTask__Group_3_0__2__Impl 7495
7496 @init { 7496rule__IntervallNumber__Group__1__Impl
7497 int stackSize = keepStackSize(); 7497 @init {
7498 } 7498 int stackSize = keepStackSize();
7499: 7499 }
7500( 7500:
7501 { before(grammarAccess.getGenerationTaskAccess().getMetamodelAssignment_3_0_2()); } 7501(
7502 (rule__GenerationTask__MetamodelAssignment_3_0_2) 7502 { before(grammarAccess.getIntervallNumberAccess().getFullStopFullStopKeyword_1()); }
7503 { after(grammarAccess.getGenerationTaskAccess().getMetamodelAssignment_3_0_2()); } 7503 '..'
7504) 7504 { after(grammarAccess.getIntervallNumberAccess().getFullStopFullStopKeyword_1()); }
7505; 7505)
7506finally { 7506;
7507 restoreStackSize(stackSize); 7507finally {
7508} 7508 restoreStackSize(stackSize);
7509 7509}
7510 7510
7511rule__GenerationTask__Group_3_1__0 7511rule__IntervallNumber__Group__2
7512 @init { 7512 @init {
7513 int stackSize = keepStackSize(); 7513 int stackSize = keepStackSize();
7514 } 7514 }
7515: 7515:
7516 rule__GenerationTask__Group_3_1__0__Impl 7516 rule__IntervallNumber__Group__2__Impl
7517 rule__GenerationTask__Group_3_1__1 7517;
7518; 7518finally {
7519finally { 7519 restoreStackSize(stackSize);
7520 restoreStackSize(stackSize); 7520}
7521} 7521
7522 7522rule__IntervallNumber__Group__2__Impl
7523rule__GenerationTask__Group_3_1__0__Impl 7523 @init {
7524 @init { 7524 int stackSize = keepStackSize();
7525 int stackSize = keepStackSize(); 7525 }
7526 } 7526:
7527: 7527(
7528( 7528 { before(grammarAccess.getIntervallNumberAccess().getAlternatives_2()); }
7529 { before(grammarAccess.getGenerationTaskAccess().getPartialModelKeyword_3_1_0()); } 7529 (rule__IntervallNumber__Alternatives_2)
7530 'partial-model' 7530 { after(grammarAccess.getIntervallNumberAccess().getAlternatives_2()); }
7531 { after(grammarAccess.getGenerationTaskAccess().getPartialModelKeyword_3_1_0()); } 7531)
7532) 7532;
7533; 7533finally {
7534finally { 7534 restoreStackSize(stackSize);
7535 restoreStackSize(stackSize); 7535}
7536} 7536
7537 7537
7538rule__GenerationTask__Group_3_1__1 7538rule__IntEnumberation__Group__0
7539 @init { 7539 @init {
7540 int stackSize = keepStackSize(); 7540 int stackSize = keepStackSize();
7541 } 7541 }
7542: 7542:
7543 rule__GenerationTask__Group_3_1__1__Impl 7543 rule__IntEnumberation__Group__0__Impl
7544 rule__GenerationTask__Group_3_1__2 7544 rule__IntEnumberation__Group__1
7545; 7545;
7546finally { 7546finally {
7547 restoreStackSize(stackSize); 7547 restoreStackSize(stackSize);
7548} 7548}
7549 7549
7550rule__GenerationTask__Group_3_1__1__Impl 7550rule__IntEnumberation__Group__0__Impl
7551 @init { 7551 @init {
7552 int stackSize = keepStackSize(); 7552 int stackSize = keepStackSize();
7553 } 7553 }
7554: 7554:
7555( 7555(
7556 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_1_1()); } 7556 { before(grammarAccess.getIntEnumberationAccess().getIntEnumberationAction_0()); }
7557 '=' 7557 ()
7558 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_1_1()); } 7558 { after(grammarAccess.getIntEnumberationAccess().getIntEnumberationAction_0()); }
7559) 7559)
7560; 7560;
7561finally { 7561finally {
7562 restoreStackSize(stackSize); 7562 restoreStackSize(stackSize);
7563} 7563}
7564 7564
7565rule__GenerationTask__Group_3_1__2 7565rule__IntEnumberation__Group__1
7566 @init { 7566 @init {
7567 int stackSize = keepStackSize(); 7567 int stackSize = keepStackSize();
7568 } 7568 }
7569: 7569:
7570 rule__GenerationTask__Group_3_1__2__Impl 7570 rule__IntEnumberation__Group__1__Impl
7571; 7571 rule__IntEnumberation__Group__2
7572finally { 7572;
7573 restoreStackSize(stackSize); 7573finally {
7574} 7574 restoreStackSize(stackSize);
7575 7575}
7576rule__GenerationTask__Group_3_1__2__Impl 7576
7577 @init { 7577rule__IntEnumberation__Group__1__Impl
7578 int stackSize = keepStackSize(); 7578 @init {
7579 } 7579 int stackSize = keepStackSize();
7580: 7580 }
7581( 7581:
7582 { before(grammarAccess.getGenerationTaskAccess().getPartialModelAssignment_3_1_2()); } 7582(
7583 (rule__GenerationTask__PartialModelAssignment_3_1_2) 7583 { before(grammarAccess.getIntEnumberationAccess().getLeftCurlyBracketKeyword_1()); }
7584 { after(grammarAccess.getGenerationTaskAccess().getPartialModelAssignment_3_1_2()); } 7584 '{'
7585) 7585 { after(grammarAccess.getIntEnumberationAccess().getLeftCurlyBracketKeyword_1()); }
7586; 7586)
7587finally { 7587;
7588 restoreStackSize(stackSize); 7588finally {
7589} 7589 restoreStackSize(stackSize);
7590 7590}
7591 7591
7592rule__GenerationTask__Group_3_2__0 7592rule__IntEnumberation__Group__2
7593 @init { 7593 @init {
7594 int stackSize = keepStackSize(); 7594 int stackSize = keepStackSize();
7595 } 7595 }
7596: 7596:
7597 rule__GenerationTask__Group_3_2__0__Impl 7597 rule__IntEnumberation__Group__2__Impl
7598 rule__GenerationTask__Group_3_2__1 7598 rule__IntEnumberation__Group__3
7599; 7599;
7600finally { 7600finally {
7601 restoreStackSize(stackSize); 7601 restoreStackSize(stackSize);
7602} 7602}
7603 7603
7604rule__GenerationTask__Group_3_2__0__Impl 7604rule__IntEnumberation__Group__2__Impl
7605 @init { 7605 @init {
7606 int stackSize = keepStackSize(); 7606 int stackSize = keepStackSize();
7607 } 7607 }
7608: 7608:
7609( 7609(
7610 { before(grammarAccess.getGenerationTaskAccess().getConstraintsKeyword_3_2_0()); } 7610 { before(grammarAccess.getIntEnumberationAccess().getGroup_2()); }
7611 'constraints' 7611 (rule__IntEnumberation__Group_2__0)?
7612 { after(grammarAccess.getGenerationTaskAccess().getConstraintsKeyword_3_2_0()); } 7612 { after(grammarAccess.getIntEnumberationAccess().getGroup_2()); }
7613) 7613)
7614; 7614;
7615finally { 7615finally {
7616 restoreStackSize(stackSize); 7616 restoreStackSize(stackSize);
7617} 7617}
7618 7618
7619rule__GenerationTask__Group_3_2__1 7619rule__IntEnumberation__Group__3
7620 @init { 7620 @init {
7621 int stackSize = keepStackSize(); 7621 int stackSize = keepStackSize();
7622 } 7622 }
7623: 7623:
7624 rule__GenerationTask__Group_3_2__1__Impl 7624 rule__IntEnumberation__Group__3__Impl
7625 rule__GenerationTask__Group_3_2__2 7625;
7626; 7626finally {
7627finally { 7627 restoreStackSize(stackSize);
7628 restoreStackSize(stackSize); 7628}
7629} 7629
7630 7630rule__IntEnumberation__Group__3__Impl
7631rule__GenerationTask__Group_3_2__1__Impl 7631 @init {
7632 @init { 7632 int stackSize = keepStackSize();
7633 int stackSize = keepStackSize(); 7633 }
7634 } 7634:
7635: 7635(
7636( 7636 { before(grammarAccess.getIntEnumberationAccess().getRightCurlyBracketKeyword_3()); }
7637 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_2_1()); } 7637 '}'
7638 '=' 7638 { after(grammarAccess.getIntEnumberationAccess().getRightCurlyBracketKeyword_3()); }
7639 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_2_1()); } 7639)
7640) 7640;
7641; 7641finally {
7642finally { 7642 restoreStackSize(stackSize);
7643 restoreStackSize(stackSize); 7643}
7644} 7644
7645 7645
7646rule__GenerationTask__Group_3_2__2 7646rule__IntEnumberation__Group_2__0
7647 @init { 7647 @init {
7648 int stackSize = keepStackSize(); 7648 int stackSize = keepStackSize();
7649 } 7649 }
7650: 7650:
7651 rule__GenerationTask__Group_3_2__2__Impl 7651 rule__IntEnumberation__Group_2__0__Impl
7652; 7652 rule__IntEnumberation__Group_2__1
7653finally { 7653;
7654 restoreStackSize(stackSize); 7654finally {
7655} 7655 restoreStackSize(stackSize);
7656 7656}
7657rule__GenerationTask__Group_3_2__2__Impl 7657
7658 @init { 7658rule__IntEnumberation__Group_2__0__Impl
7659 int stackSize = keepStackSize(); 7659 @init {
7660 } 7660 int stackSize = keepStackSize();
7661: 7661 }
7662( 7662:
7663 { before(grammarAccess.getGenerationTaskAccess().getPatternsAssignment_3_2_2()); } 7663(
7664 (rule__GenerationTask__PatternsAssignment_3_2_2) 7664 { before(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_0()); }
7665 { after(grammarAccess.getGenerationTaskAccess().getPatternsAssignment_3_2_2()); } 7665 (rule__IntEnumberation__EntryAssignment_2_0)
7666) 7666 { after(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_0()); }
7667; 7667)
7668finally { 7668;
7669 restoreStackSize(stackSize); 7669finally {
7670} 7670 restoreStackSize(stackSize);
7671 7671}
7672 7672
7673rule__GenerationTask__Group_3_3__0 7673rule__IntEnumberation__Group_2__1
7674 @init { 7674 @init {
7675 int stackSize = keepStackSize(); 7675 int stackSize = keepStackSize();
7676 } 7676 }
7677: 7677:
7678 rule__GenerationTask__Group_3_3__0__Impl 7678 rule__IntEnumberation__Group_2__1__Impl
7679 rule__GenerationTask__Group_3_3__1 7679;
7680; 7680finally {
7681finally { 7681 restoreStackSize(stackSize);
7682 restoreStackSize(stackSize); 7682}
7683} 7683
7684 7684rule__IntEnumberation__Group_2__1__Impl
7685rule__GenerationTask__Group_3_3__0__Impl 7685 @init {
7686 @init { 7686 int stackSize = keepStackSize();
7687 int stackSize = keepStackSize(); 7687 }
7688 } 7688:
7689: 7689(
7690( 7690 { before(grammarAccess.getIntEnumberationAccess().getGroup_2_1()); }
7691 { before(grammarAccess.getGenerationTaskAccess().getScopeKeyword_3_3_0()); } 7691 (rule__IntEnumberation__Group_2_1__0)*
7692 'scope' 7692 { after(grammarAccess.getIntEnumberationAccess().getGroup_2_1()); }
7693 { after(grammarAccess.getGenerationTaskAccess().getScopeKeyword_3_3_0()); } 7693)
7694) 7694;
7695; 7695finally {
7696finally { 7696 restoreStackSize(stackSize);
7697 restoreStackSize(stackSize); 7697}
7698} 7698
7699 7699
7700rule__GenerationTask__Group_3_3__1 7700rule__IntEnumberation__Group_2_1__0
7701 @init { 7701 @init {
7702 int stackSize = keepStackSize(); 7702 int stackSize = keepStackSize();
7703 } 7703 }
7704: 7704:
7705 rule__GenerationTask__Group_3_3__1__Impl 7705 rule__IntEnumberation__Group_2_1__0__Impl
7706 rule__GenerationTask__Group_3_3__2 7706 rule__IntEnumberation__Group_2_1__1
7707; 7707;
7708finally { 7708finally {
7709 restoreStackSize(stackSize); 7709 restoreStackSize(stackSize);
7710} 7710}
7711 7711
7712rule__GenerationTask__Group_3_3__1__Impl 7712rule__IntEnumberation__Group_2_1__0__Impl
7713 @init { 7713 @init {
7714 int stackSize = keepStackSize(); 7714 int stackSize = keepStackSize();
7715 } 7715 }
7716: 7716:
7717( 7717(
7718 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_3_1()); } 7718 { before(grammarAccess.getIntEnumberationAccess().getCommaKeyword_2_1_0()); }
7719 '=' 7719 ','
7720 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_3_1()); } 7720 { after(grammarAccess.getIntEnumberationAccess().getCommaKeyword_2_1_0()); }
7721) 7721)
7722; 7722;
7723finally { 7723finally {
7724 restoreStackSize(stackSize); 7724 restoreStackSize(stackSize);
7725} 7725}
7726 7726
7727rule__GenerationTask__Group_3_3__2 7727rule__IntEnumberation__Group_2_1__1
7728 @init { 7728 @init {
7729 int stackSize = keepStackSize(); 7729 int stackSize = keepStackSize();
7730 } 7730 }
7731: 7731:
7732 rule__GenerationTask__Group_3_3__2__Impl 7732 rule__IntEnumberation__Group_2_1__1__Impl
7733; 7733;
7734finally { 7734finally {
7735 restoreStackSize(stackSize); 7735 restoreStackSize(stackSize);
7736} 7736}
7737 7737
7738rule__GenerationTask__Group_3_3__2__Impl 7738rule__IntEnumberation__Group_2_1__1__Impl
7739 @init { 7739 @init {
7740 int stackSize = keepStackSize(); 7740 int stackSize = keepStackSize();
7741 } 7741 }
7742: 7742:
7743( 7743(
7744 { before(grammarAccess.getGenerationTaskAccess().getScopeAssignment_3_3_2()); } 7744 { before(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_1_1()); }
7745 (rule__GenerationTask__ScopeAssignment_3_3_2) 7745 (rule__IntEnumberation__EntryAssignment_2_1_1)
7746 { after(grammarAccess.getGenerationTaskAccess().getScopeAssignment_3_3_2()); } 7746 { after(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_1_1()); }
7747) 7747)
7748; 7748;
7749finally { 7749finally {
7750 restoreStackSize(stackSize); 7750 restoreStackSize(stackSize);
7751} 7751}
7752 7752
7753 7753
7754rule__GenerationTask__Group_3_4__0 7754rule__RealEnumeration__Group__0
7755 @init { 7755 @init {
7756 int stackSize = keepStackSize(); 7756 int stackSize = keepStackSize();
7757 } 7757 }
7758: 7758:
7759 rule__GenerationTask__Group_3_4__0__Impl 7759 rule__RealEnumeration__Group__0__Impl
7760 rule__GenerationTask__Group_3_4__1 7760 rule__RealEnumeration__Group__1
7761; 7761;
7762finally { 7762finally {
7763 restoreStackSize(stackSize); 7763 restoreStackSize(stackSize);
7764} 7764}
7765 7765
7766rule__GenerationTask__Group_3_4__0__Impl 7766rule__RealEnumeration__Group__0__Impl
7767 @init { 7767 @init {
7768 int stackSize = keepStackSize(); 7768 int stackSize = keepStackSize();
7769 } 7769 }
7770: 7770:
7771( 7771(
7772 { before(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedAssignment_3_4_0()); } 7772 { before(grammarAccess.getRealEnumerationAccess().getRealEnumerationAction_0()); }
7773 (rule__GenerationTask__NumberSpecifiedAssignment_3_4_0) 7773 ()
7774 { after(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedAssignment_3_4_0()); } 7774 { after(grammarAccess.getRealEnumerationAccess().getRealEnumerationAction_0()); }
7775) 7775)
7776; 7776;
7777finally { 7777finally {
7778 restoreStackSize(stackSize); 7778 restoreStackSize(stackSize);
7779} 7779}
7780 7780
7781rule__GenerationTask__Group_3_4__1 7781rule__RealEnumeration__Group__1
7782 @init { 7782 @init {
7783 int stackSize = keepStackSize(); 7783 int stackSize = keepStackSize();
7784 } 7784 }
7785: 7785:
7786 rule__GenerationTask__Group_3_4__1__Impl 7786 rule__RealEnumeration__Group__1__Impl
7787 rule__GenerationTask__Group_3_4__2 7787 rule__RealEnumeration__Group__2
7788; 7788;
7789finally { 7789finally {
7790 restoreStackSize(stackSize); 7790 restoreStackSize(stackSize);
7791} 7791}
7792 7792
7793rule__GenerationTask__Group_3_4__1__Impl 7793rule__RealEnumeration__Group__1__Impl
7794 @init { 7794 @init {
7795 int stackSize = keepStackSize(); 7795 int stackSize = keepStackSize();
7796 } 7796 }
7797: 7797:
7798( 7798(
7799 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_4_1()); } 7799 { before(grammarAccess.getRealEnumerationAccess().getLeftCurlyBracketKeyword_1()); }
7800 '=' 7800 '{'
7801 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_4_1()); } 7801 { after(grammarAccess.getRealEnumerationAccess().getLeftCurlyBracketKeyword_1()); }
7802) 7802)
7803; 7803;
7804finally { 7804finally {
7805 restoreStackSize(stackSize); 7805 restoreStackSize(stackSize);
7806} 7806}
7807 7807
7808rule__GenerationTask__Group_3_4__2 7808rule__RealEnumeration__Group__2
7809 @init { 7809 @init {
7810 int stackSize = keepStackSize(); 7810 int stackSize = keepStackSize();
7811 } 7811 }
7812: 7812:
7813 rule__GenerationTask__Group_3_4__2__Impl 7813 rule__RealEnumeration__Group__2__Impl
7814; 7814 rule__RealEnumeration__Group__3
7815finally { 7815;
7816 restoreStackSize(stackSize); 7816finally {
7817} 7817 restoreStackSize(stackSize);
7818 7818}
7819rule__GenerationTask__Group_3_4__2__Impl 7819
7820 @init { 7820rule__RealEnumeration__Group__2__Impl
7821 int stackSize = keepStackSize(); 7821 @init {
7822 } 7822 int stackSize = keepStackSize();
7823: 7823 }
7824( 7824:
7825 { before(grammarAccess.getGenerationTaskAccess().getNumberAssignment_3_4_2()); } 7825(
7826 (rule__GenerationTask__NumberAssignment_3_4_2) 7826 { before(grammarAccess.getRealEnumerationAccess().getGroup_2()); }
7827 { after(grammarAccess.getGenerationTaskAccess().getNumberAssignment_3_4_2()); } 7827 (rule__RealEnumeration__Group_2__0)?
7828) 7828 { after(grammarAccess.getRealEnumerationAccess().getGroup_2()); }
7829; 7829)
7830finally { 7830;
7831 restoreStackSize(stackSize); 7831finally {
7832} 7832 restoreStackSize(stackSize);
7833 7833}
7834 7834
7835rule__GenerationTask__Group_3_5__0 7835rule__RealEnumeration__Group__3
7836 @init { 7836 @init {
7837 int stackSize = keepStackSize(); 7837 int stackSize = keepStackSize();
7838 } 7838 }
7839: 7839:
7840 rule__GenerationTask__Group_3_5__0__Impl 7840 rule__RealEnumeration__Group__3__Impl
7841 rule__GenerationTask__Group_3_5__1 7841;
7842; 7842finally {
7843finally { 7843 restoreStackSize(stackSize);
7844 restoreStackSize(stackSize); 7844}
7845} 7845
7846 7846rule__RealEnumeration__Group__3__Impl
7847rule__GenerationTask__Group_3_5__0__Impl 7847 @init {
7848 @init { 7848 int stackSize = keepStackSize();
7849 int stackSize = keepStackSize(); 7849 }
7850 } 7850:
7851: 7851(
7852( 7852 { before(grammarAccess.getRealEnumerationAccess().getRightCurlyBracketKeyword_3()); }
7853 { before(grammarAccess.getGenerationTaskAccess().getRunSpecifiedAssignment_3_5_0()); } 7853 '}'
7854 (rule__GenerationTask__RunSpecifiedAssignment_3_5_0) 7854 { after(grammarAccess.getRealEnumerationAccess().getRightCurlyBracketKeyword_3()); }
7855 { after(grammarAccess.getGenerationTaskAccess().getRunSpecifiedAssignment_3_5_0()); } 7855)
7856) 7856;
7857; 7857finally {
7858finally { 7858 restoreStackSize(stackSize);
7859 restoreStackSize(stackSize); 7859}
7860} 7860
7861 7861
7862rule__GenerationTask__Group_3_5__1 7862rule__RealEnumeration__Group_2__0
7863 @init { 7863 @init {
7864 int stackSize = keepStackSize(); 7864 int stackSize = keepStackSize();
7865 } 7865 }
7866: 7866:
7867 rule__GenerationTask__Group_3_5__1__Impl 7867 rule__RealEnumeration__Group_2__0__Impl
7868 rule__GenerationTask__Group_3_5__2 7868 rule__RealEnumeration__Group_2__1
7869; 7869;
7870finally { 7870finally {
7871 restoreStackSize(stackSize); 7871 restoreStackSize(stackSize);
7872} 7872}
7873 7873
7874rule__GenerationTask__Group_3_5__1__Impl 7874rule__RealEnumeration__Group_2__0__Impl
7875 @init { 7875 @init {
7876 int stackSize = keepStackSize(); 7876 int stackSize = keepStackSize();
7877 } 7877 }
7878: 7878:
7879( 7879(
7880 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_5_1()); } 7880 { before(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_0()); }
7881 '=' 7881 (rule__RealEnumeration__EntryAssignment_2_0)
7882 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_5_1()); } 7882 { after(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_0()); }
7883) 7883)
7884; 7884;
7885finally { 7885finally {
7886 restoreStackSize(stackSize); 7886 restoreStackSize(stackSize);
7887} 7887}
7888 7888
7889rule__GenerationTask__Group_3_5__2 7889rule__RealEnumeration__Group_2__1
7890 @init { 7890 @init {
7891 int stackSize = keepStackSize(); 7891 int stackSize = keepStackSize();
7892 } 7892 }
7893: 7893:
7894 rule__GenerationTask__Group_3_5__2__Impl 7894 rule__RealEnumeration__Group_2__1__Impl
7895; 7895;
7896finally { 7896finally {
7897 restoreStackSize(stackSize); 7897 restoreStackSize(stackSize);
7898} 7898}
7899 7899
7900rule__GenerationTask__Group_3_5__2__Impl 7900rule__RealEnumeration__Group_2__1__Impl
7901 @init { 7901 @init {
7902 int stackSize = keepStackSize(); 7902 int stackSize = keepStackSize();
7903 } 7903 }
7904: 7904:
7905( 7905(
7906 { before(grammarAccess.getGenerationTaskAccess().getRunsAssignment_3_5_2()); } 7906 { before(grammarAccess.getRealEnumerationAccess().getGroup_2_1()); }
7907 (rule__GenerationTask__RunsAssignment_3_5_2) 7907 (rule__RealEnumeration__Group_2_1__0)*
7908 { after(grammarAccess.getGenerationTaskAccess().getRunsAssignment_3_5_2()); } 7908 { after(grammarAccess.getRealEnumerationAccess().getGroup_2_1()); }
7909) 7909)
7910; 7910;
7911finally { 7911finally {
7912 restoreStackSize(stackSize); 7912 restoreStackSize(stackSize);
7913} 7913}
7914 7914
7915 7915
7916rule__GenerationTask__Group_3_6__0 7916rule__RealEnumeration__Group_2_1__0
7917 @init { 7917 @init {
7918 int stackSize = keepStackSize(); 7918 int stackSize = keepStackSize();
7919 } 7919 }
7920: 7920:
7921 rule__GenerationTask__Group_3_6__0__Impl 7921 rule__RealEnumeration__Group_2_1__0__Impl
7922 rule__GenerationTask__Group_3_6__1 7922 rule__RealEnumeration__Group_2_1__1
7923; 7923;
7924finally { 7924finally {
7925 restoreStackSize(stackSize); 7925 restoreStackSize(stackSize);
7926} 7926}
7927 7927
7928rule__GenerationTask__Group_3_6__0__Impl 7928rule__RealEnumeration__Group_2_1__0__Impl
7929 @init { 7929 @init {
7930 int stackSize = keepStackSize(); 7930 int stackSize = keepStackSize();
7931 } 7931 }
7932: 7932:
7933( 7933(
7934 { before(grammarAccess.getGenerationTaskAccess().getSolverKeyword_3_6_0()); } 7934 { before(grammarAccess.getRealEnumerationAccess().getCommaKeyword_2_1_0()); }
7935 'solver' 7935 ','
7936 { after(grammarAccess.getGenerationTaskAccess().getSolverKeyword_3_6_0()); } 7936 { after(grammarAccess.getRealEnumerationAccess().getCommaKeyword_2_1_0()); }
7937) 7937)
7938; 7938;
7939finally { 7939finally {
7940 restoreStackSize(stackSize); 7940 restoreStackSize(stackSize);
7941} 7941}
7942 7942
7943rule__GenerationTask__Group_3_6__1 7943rule__RealEnumeration__Group_2_1__1
7944 @init { 7944 @init {
7945 int stackSize = keepStackSize(); 7945 int stackSize = keepStackSize();
7946 } 7946 }
7947: 7947:
7948 rule__GenerationTask__Group_3_6__1__Impl 7948 rule__RealEnumeration__Group_2_1__1__Impl
7949 rule__GenerationTask__Group_3_6__2 7949;
7950; 7950finally {
7951finally { 7951 restoreStackSize(stackSize);
7952 restoreStackSize(stackSize); 7952}
7953} 7953
7954 7954rule__RealEnumeration__Group_2_1__1__Impl
7955rule__GenerationTask__Group_3_6__1__Impl 7955 @init {
7956 @init { 7956 int stackSize = keepStackSize();
7957 int stackSize = keepStackSize(); 7957 }
7958 } 7958:
7959: 7959(
7960( 7960 { before(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_1_1()); }
7961 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_6_1()); } 7961 (rule__RealEnumeration__EntryAssignment_2_1_1)
7962 '=' 7962 { after(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_1_1()); }
7963 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_6_1()); } 7963)
7964) 7964;
7965; 7965finally {
7966finally { 7966 restoreStackSize(stackSize);
7967 restoreStackSize(stackSize); 7967}
7968} 7968
7969 7969
7970rule__GenerationTask__Group_3_6__2 7970rule__StringEnumeration__Group__0
7971 @init { 7971 @init {
7972 int stackSize = keepStackSize(); 7972 int stackSize = keepStackSize();
7973 } 7973 }
7974: 7974:
7975 rule__GenerationTask__Group_3_6__2__Impl 7975 rule__StringEnumeration__Group__0__Impl
7976; 7976 rule__StringEnumeration__Group__1
7977finally { 7977;
7978 restoreStackSize(stackSize); 7978finally {
7979} 7979 restoreStackSize(stackSize);
7980 7980}
7981rule__GenerationTask__Group_3_6__2__Impl 7981
7982 @init { 7982rule__StringEnumeration__Group__0__Impl
7983 int stackSize = keepStackSize(); 7983 @init {
7984 } 7984 int stackSize = keepStackSize();
7985: 7985 }
7986( 7986:
7987 { before(grammarAccess.getGenerationTaskAccess().getSolverAssignment_3_6_2()); } 7987(
7988 (rule__GenerationTask__SolverAssignment_3_6_2) 7988 { before(grammarAccess.getStringEnumerationAccess().getStringEnumerationAction_0()); }
7989 { after(grammarAccess.getGenerationTaskAccess().getSolverAssignment_3_6_2()); } 7989 ()
7990) 7990 { after(grammarAccess.getStringEnumerationAccess().getStringEnumerationAction_0()); }
7991; 7991)
7992finally { 7992;
7993 restoreStackSize(stackSize); 7993finally {
7994} 7994 restoreStackSize(stackSize);
7995 7995}
7996 7996
7997rule__GenerationTask__Group_3_7__0 7997rule__StringEnumeration__Group__1
7998 @init { 7998 @init {
7999 int stackSize = keepStackSize(); 7999 int stackSize = keepStackSize();
8000 } 8000 }
8001: 8001:
8002 rule__GenerationTask__Group_3_7__0__Impl 8002 rule__StringEnumeration__Group__1__Impl
8003 rule__GenerationTask__Group_3_7__1 8003 rule__StringEnumeration__Group__2
8004; 8004;
8005finally { 8005finally {
8006 restoreStackSize(stackSize); 8006 restoreStackSize(stackSize);
8007} 8007}
8008 8008
8009rule__GenerationTask__Group_3_7__0__Impl 8009rule__StringEnumeration__Group__1__Impl
8010 @init { 8010 @init {
8011 int stackSize = keepStackSize(); 8011 int stackSize = keepStackSize();
8012 } 8012 }
8013: 8013:
8014( 8014(
8015 { before(grammarAccess.getGenerationTaskAccess().getConfigKeyword_3_7_0()); } 8015 { before(grammarAccess.getStringEnumerationAccess().getLeftCurlyBracketKeyword_1()); }
8016 'config' 8016 '{'
8017 { after(grammarAccess.getGenerationTaskAccess().getConfigKeyword_3_7_0()); } 8017 { after(grammarAccess.getStringEnumerationAccess().getLeftCurlyBracketKeyword_1()); }
8018) 8018)
8019; 8019;
8020finally { 8020finally {
8021 restoreStackSize(stackSize); 8021 restoreStackSize(stackSize);
8022} 8022}
8023 8023
8024rule__GenerationTask__Group_3_7__1 8024rule__StringEnumeration__Group__2
8025 @init { 8025 @init {
8026 int stackSize = keepStackSize(); 8026 int stackSize = keepStackSize();
8027 } 8027 }
8028: 8028:
8029 rule__GenerationTask__Group_3_7__1__Impl 8029 rule__StringEnumeration__Group__2__Impl
8030 rule__GenerationTask__Group_3_7__2 8030 rule__StringEnumeration__Group__3
8031; 8031;
8032finally { 8032finally {
8033 restoreStackSize(stackSize); 8033 restoreStackSize(stackSize);
8034} 8034}
8035 8035
8036rule__GenerationTask__Group_3_7__1__Impl 8036rule__StringEnumeration__Group__2__Impl
8037 @init { 8037 @init {
8038 int stackSize = keepStackSize(); 8038 int stackSize = keepStackSize();
8039 } 8039 }
8040: 8040:
8041( 8041(
8042 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_7_1()); } 8042 { before(grammarAccess.getStringEnumerationAccess().getGroup_2()); }
8043 '=' 8043 (rule__StringEnumeration__Group_2__0)?
8044 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_7_1()); } 8044 { after(grammarAccess.getStringEnumerationAccess().getGroup_2()); }
8045) 8045)
8046; 8046;
8047finally { 8047finally {
8048 restoreStackSize(stackSize); 8048 restoreStackSize(stackSize);
8049} 8049}
8050 8050
8051rule__GenerationTask__Group_3_7__2 8051rule__StringEnumeration__Group__3
8052 @init { 8052 @init {
8053 int stackSize = keepStackSize(); 8053 int stackSize = keepStackSize();
8054 } 8054 }
8055: 8055:
8056 rule__GenerationTask__Group_3_7__2__Impl 8056 rule__StringEnumeration__Group__3__Impl
8057; 8057;
8058finally { 8058finally {
8059 restoreStackSize(stackSize); 8059 restoreStackSize(stackSize);
8060} 8060}
8061 8061
8062rule__GenerationTask__Group_3_7__2__Impl 8062rule__StringEnumeration__Group__3__Impl
8063 @init { 8063 @init {
8064 int stackSize = keepStackSize(); 8064 int stackSize = keepStackSize();
8065 } 8065 }
8066: 8066:
8067( 8067(
8068 { before(grammarAccess.getGenerationTaskAccess().getConfigAssignment_3_7_2()); } 8068 { before(grammarAccess.getStringEnumerationAccess().getRightCurlyBracketKeyword_3()); }
8069 (rule__GenerationTask__ConfigAssignment_3_7_2) 8069 '}'
8070 { after(grammarAccess.getGenerationTaskAccess().getConfigAssignment_3_7_2()); } 8070 { after(grammarAccess.getStringEnumerationAccess().getRightCurlyBracketKeyword_3()); }
8071) 8071)
8072; 8072;
8073finally { 8073finally {
8074 restoreStackSize(stackSize); 8074 restoreStackSize(stackSize);
8075} 8075}
8076 8076
8077 8077
8078rule__GenerationTask__Group_3_8__0 8078rule__StringEnumeration__Group_2__0
8079 @init { 8079 @init {
8080 int stackSize = keepStackSize(); 8080 int stackSize = keepStackSize();
8081 } 8081 }
8082: 8082:
8083 rule__GenerationTask__Group_3_8__0__Impl 8083 rule__StringEnumeration__Group_2__0__Impl
8084 rule__GenerationTask__Group_3_8__1 8084 rule__StringEnumeration__Group_2__1
8085; 8085;
8086finally { 8086finally {
8087 restoreStackSize(stackSize); 8087 restoreStackSize(stackSize);
8088} 8088}
8089 8089
8090rule__GenerationTask__Group_3_8__0__Impl 8090rule__StringEnumeration__Group_2__0__Impl
8091 @init { 8091 @init {
8092 int stackSize = keepStackSize(); 8092 int stackSize = keepStackSize();
8093 } 8093 }
8094: 8094:
8095( 8095(
8096 { before(grammarAccess.getGenerationTaskAccess().getDebugKeyword_3_8_0()); } 8096 { before(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_0()); }
8097 'debug' 8097 (rule__StringEnumeration__EntryAssignment_2_0)
8098 { after(grammarAccess.getGenerationTaskAccess().getDebugKeyword_3_8_0()); } 8098 { after(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_0()); }
8099) 8099)
8100; 8100;
8101finally { 8101finally {
8102 restoreStackSize(stackSize); 8102 restoreStackSize(stackSize);
8103} 8103}
8104 8104
8105rule__GenerationTask__Group_3_8__1 8105rule__StringEnumeration__Group_2__1
8106 @init { 8106 @init {
8107 int stackSize = keepStackSize(); 8107 int stackSize = keepStackSize();
8108 } 8108 }
8109: 8109:
8110 rule__GenerationTask__Group_3_8__1__Impl 8110 rule__StringEnumeration__Group_2__1__Impl
8111 rule__GenerationTask__Group_3_8__2 8111;
8112; 8112finally {
8113finally { 8113 restoreStackSize(stackSize);
8114 restoreStackSize(stackSize); 8114}
8115} 8115
8116 8116rule__StringEnumeration__Group_2__1__Impl
8117rule__GenerationTask__Group_3_8__1__Impl 8117 @init {
8118 @init { 8118 int stackSize = keepStackSize();
8119 int stackSize = keepStackSize(); 8119 }
8120 } 8120:
8121: 8121(
8122( 8122 { before(grammarAccess.getStringEnumerationAccess().getGroup_2_1()); }
8123 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_8_1()); } 8123 (rule__StringEnumeration__Group_2_1__0)*
8124 '=' 8124 { after(grammarAccess.getStringEnumerationAccess().getGroup_2_1()); }
8125 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_8_1()); } 8125)
8126) 8126;
8127; 8127finally {
8128finally { 8128 restoreStackSize(stackSize);
8129 restoreStackSize(stackSize); 8129}
8130} 8130
8131 8131
8132rule__GenerationTask__Group_3_8__2 8132rule__StringEnumeration__Group_2_1__0
8133 @init { 8133 @init {
8134 int stackSize = keepStackSize(); 8134 int stackSize = keepStackSize();
8135 } 8135 }
8136: 8136:
8137 rule__GenerationTask__Group_3_8__2__Impl 8137 rule__StringEnumeration__Group_2_1__0__Impl
8138; 8138 rule__StringEnumeration__Group_2_1__1
8139finally { 8139;
8140 restoreStackSize(stackSize); 8140finally {
8141} 8141 restoreStackSize(stackSize);
8142 8142}
8143rule__GenerationTask__Group_3_8__2__Impl 8143
8144 @init { 8144rule__StringEnumeration__Group_2_1__0__Impl
8145 int stackSize = keepStackSize(); 8145 @init {
8146 } 8146 int stackSize = keepStackSize();
8147: 8147 }
8148( 8148:
8149 { before(grammarAccess.getGenerationTaskAccess().getDebugFolderAssignment_3_8_2()); } 8149(
8150 (rule__GenerationTask__DebugFolderAssignment_3_8_2) 8150 { before(grammarAccess.getStringEnumerationAccess().getCommaKeyword_2_1_0()); }
8151 { after(grammarAccess.getGenerationTaskAccess().getDebugFolderAssignment_3_8_2()); } 8151 ','
8152) 8152 { after(grammarAccess.getStringEnumerationAccess().getCommaKeyword_2_1_0()); }
8153; 8153)
8154finally { 8154;
8155 restoreStackSize(stackSize); 8155finally {
8156} 8156 restoreStackSize(stackSize);
8157 8157}
8158 8158
8159rule__GenerationTask__Group_3_9__0 8159rule__StringEnumeration__Group_2_1__1
8160 @init { 8160 @init {
8161 int stackSize = keepStackSize(); 8161 int stackSize = keepStackSize();
8162 } 8162 }
8163: 8163:
8164 rule__GenerationTask__Group_3_9__0__Impl 8164 rule__StringEnumeration__Group_2_1__1__Impl
8165 rule__GenerationTask__Group_3_9__1 8165;
8166; 8166finally {
8167finally { 8167 restoreStackSize(stackSize);
8168 restoreStackSize(stackSize); 8168}
8169} 8169
8170 8170rule__StringEnumeration__Group_2_1__1__Impl
8171rule__GenerationTask__Group_3_9__0__Impl 8171 @init {
8172 @init { 8172 int stackSize = keepStackSize();
8173 int stackSize = keepStackSize(); 8173 }
8174 } 8174:
8175: 8175(
8176( 8176 { before(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_1_1()); }
8177 { before(grammarAccess.getGenerationTaskAccess().getLogKeyword_3_9_0()); } 8177 (rule__StringEnumeration__EntryAssignment_2_1_1)
8178 'log' 8178 { after(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_1_1()); }
8179 { after(grammarAccess.getGenerationTaskAccess().getLogKeyword_3_9_0()); } 8179)
8180) 8180;
8181; 8181finally {
8182finally { 8182 restoreStackSize(stackSize);
8183 restoreStackSize(stackSize); 8183}
8184} 8184
8185 8185
8186rule__GenerationTask__Group_3_9__1 8186rule__ScopeDeclaration__Group__0
8187 @init { 8187 @init {
8188 int stackSize = keepStackSize(); 8188 int stackSize = keepStackSize();
8189 } 8189 }
8190: 8190:
8191 rule__GenerationTask__Group_3_9__1__Impl 8191 rule__ScopeDeclaration__Group__0__Impl
8192 rule__GenerationTask__Group_3_9__2 8192 rule__ScopeDeclaration__Group__1
8193; 8193;
8194finally { 8194finally {
8195 restoreStackSize(stackSize); 8195 restoreStackSize(stackSize);
8196} 8196}
8197 8197
8198rule__GenerationTask__Group_3_9__1__Impl 8198rule__ScopeDeclaration__Group__0__Impl
8199 @init { 8199 @init {
8200 int stackSize = keepStackSize(); 8200 int stackSize = keepStackSize();
8201 } 8201 }
8202: 8202:
8203( 8203(
8204 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_9_1()); } 8204 { before(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); }
8205 '=' 8205 'scope'
8206 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_9_1()); } 8206 { after(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); }
8207) 8207)
8208; 8208;
8209finally { 8209finally {
8210 restoreStackSize(stackSize); 8210 restoreStackSize(stackSize);
8211} 8211}
8212 8212
8213rule__GenerationTask__Group_3_9__2 8213rule__ScopeDeclaration__Group__1
8214 @init { 8214 @init {
8215 int stackSize = keepStackSize(); 8215 int stackSize = keepStackSize();
8216 } 8216 }
8217: 8217:
8218 rule__GenerationTask__Group_3_9__2__Impl 8218 rule__ScopeDeclaration__Group__1__Impl
8219; 8219 rule__ScopeDeclaration__Group__2
8220finally { 8220;
8221 restoreStackSize(stackSize); 8221finally {
8222} 8222 restoreStackSize(stackSize);
8223 8223}
8224rule__GenerationTask__Group_3_9__2__Impl 8224
8225 @init { 8225rule__ScopeDeclaration__Group__1__Impl
8226 int stackSize = keepStackSize(); 8226 @init {
8227 } 8227 int stackSize = keepStackSize();
8228: 8228 }
8229( 8229:
8230 { before(grammarAccess.getGenerationTaskAccess().getTargetLogFileAssignment_3_9_2()); } 8230(
8231 (rule__GenerationTask__TargetLogFileAssignment_3_9_2) 8231 { before(grammarAccess.getScopeDeclarationAccess().getNameAssignment_1()); }
8232 { after(grammarAccess.getGenerationTaskAccess().getTargetLogFileAssignment_3_9_2()); } 8232 (rule__ScopeDeclaration__NameAssignment_1)
8233) 8233 { after(grammarAccess.getScopeDeclarationAccess().getNameAssignment_1()); }
8234; 8234)
8235finally { 8235;
8236 restoreStackSize(stackSize); 8236finally {
8237} 8237 restoreStackSize(stackSize);
8238 8238}
8239 8239
8240rule__GenerationTask__Group_3_10__0 8240rule__ScopeDeclaration__Group__2
8241 @init { 8241 @init {
8242 int stackSize = keepStackSize(); 8242 int stackSize = keepStackSize();
8243 } 8243 }
8244: 8244:
8245 rule__GenerationTask__Group_3_10__0__Impl 8245 rule__ScopeDeclaration__Group__2__Impl
8246 rule__GenerationTask__Group_3_10__1 8246;
8247; 8247finally {
8248finally { 8248 restoreStackSize(stackSize);
8249 restoreStackSize(stackSize); 8249}
8250} 8250
8251 8251rule__ScopeDeclaration__Group__2__Impl
8252rule__GenerationTask__Group_3_10__0__Impl 8252 @init {
8253 @init { 8253 int stackSize = keepStackSize();
8254 int stackSize = keepStackSize(); 8254 }
8255 } 8255:
8256: 8256(
8257( 8257 { before(grammarAccess.getScopeDeclarationAccess().getSpecificationAssignment_2()); }
8258 { before(grammarAccess.getGenerationTaskAccess().getStatisticsKeyword_3_10_0()); } 8258 (rule__ScopeDeclaration__SpecificationAssignment_2)
8259 'statistics' 8259 { after(grammarAccess.getScopeDeclarationAccess().getSpecificationAssignment_2()); }
8260 { after(grammarAccess.getGenerationTaskAccess().getStatisticsKeyword_3_10_0()); } 8260)
8261) 8261;
8262; 8262finally {
8263finally { 8263 restoreStackSize(stackSize);
8264 restoreStackSize(stackSize); 8264}
8265} 8265
8266 8266
8267rule__GenerationTask__Group_3_10__1 8267rule__GenerationTask__Group__0
8268 @init { 8268 @init {
8269 int stackSize = keepStackSize(); 8269 int stackSize = keepStackSize();
8270 } 8270 }
8271: 8271:
8272 rule__GenerationTask__Group_3_10__1__Impl 8272 rule__GenerationTask__Group__0__Impl
8273 rule__GenerationTask__Group_3_10__2 8273 rule__GenerationTask__Group__1
8274; 8274;
8275finally { 8275finally {
8276 restoreStackSize(stackSize); 8276 restoreStackSize(stackSize);
8277} 8277}
8278 8278
8279rule__GenerationTask__Group_3_10__1__Impl 8279rule__GenerationTask__Group__0__Impl
8280 @init { 8280 @init {
8281 int stackSize = keepStackSize(); 8281 int stackSize = keepStackSize();
8282 } 8282 }
8283: 8283:
8284( 8284(
8285 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_10_1()); } 8285 { before(grammarAccess.getGenerationTaskAccess().getGenerateKeyword_0()); }
8286 '=' 8286 'generate'
8287 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_10_1()); } 8287 { after(grammarAccess.getGenerationTaskAccess().getGenerateKeyword_0()); }
8288) 8288)
8289; 8289;
8290finally { 8290finally {
8291 restoreStackSize(stackSize); 8291 restoreStackSize(stackSize);
8292} 8292}
8293 8293
8294rule__GenerationTask__Group_3_10__2 8294rule__GenerationTask__Group__1
8295 @init { 8295 @init {
8296 int stackSize = keepStackSize(); 8296 int stackSize = keepStackSize();
8297 } 8297 }
8298: 8298:
8299 rule__GenerationTask__Group_3_10__2__Impl 8299 rule__GenerationTask__Group__1__Impl
8300; 8300 rule__GenerationTask__Group__2
8301finally { 8301;
8302 restoreStackSize(stackSize); 8302finally {
8303} 8303 restoreStackSize(stackSize);
8304 8304}
8305rule__GenerationTask__Group_3_10__2__Impl 8305
8306 @init { 8306rule__GenerationTask__Group__1__Impl
8307 int stackSize = keepStackSize(); 8307 @init {
8308 } 8308 int stackSize = keepStackSize();
8309: 8309 }
8310( 8310:
8311 { before(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileAssignment_3_10_2()); } 8311(
8312 (rule__GenerationTask__TargetStatisticsFileAssignment_3_10_2) 8312 { before(grammarAccess.getGenerationTaskAccess().getGenerationTaskAction_1()); }
8313 { after(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileAssignment_3_10_2()); } 8313 ()
8314) 8314 { after(grammarAccess.getGenerationTaskAccess().getGenerationTaskAction_1()); }
8315; 8315)
8316finally { 8316;
8317 restoreStackSize(stackSize); 8317finally {
8318} 8318 restoreStackSize(stackSize);
8319 8319}
8320 8320
8321rule__GenerationTask__Group_3_11__0 8321rule__GenerationTask__Group__2
8322 @init { 8322 @init {
8323 int stackSize = keepStackSize(); 8323 int stackSize = keepStackSize();
8324 } 8324 }
8325: 8325:
8326 rule__GenerationTask__Group_3_11__0__Impl 8326 rule__GenerationTask__Group__2__Impl
8327 rule__GenerationTask__Group_3_11__1 8327 rule__GenerationTask__Group__3
8328; 8328;
8329finally { 8329finally {
8330 restoreStackSize(stackSize); 8330 restoreStackSize(stackSize);
8331} 8331}
8332 8332
8333rule__GenerationTask__Group_3_11__0__Impl 8333rule__GenerationTask__Group__2__Impl
8334 @init { 8334 @init {
8335 int stackSize = keepStackSize(); 8335 int stackSize = keepStackSize();
8336 } 8336 }
8337: 8337:
8338( 8338(
8339 { before(grammarAccess.getGenerationTaskAccess().getOutputKeyword_3_11_0()); } 8339 { before(grammarAccess.getGenerationTaskAccess().getLeftCurlyBracketKeyword_2()); }
8340 'output' 8340 '{'
8341 { after(grammarAccess.getGenerationTaskAccess().getOutputKeyword_3_11_0()); } 8341 { after(grammarAccess.getGenerationTaskAccess().getLeftCurlyBracketKeyword_2()); }
8342) 8342)
8343; 8343;
8344finally { 8344finally {
8345 restoreStackSize(stackSize); 8345 restoreStackSize(stackSize);
8346} 8346}
8347 8347
8348rule__GenerationTask__Group_3_11__1 8348rule__GenerationTask__Group__3
8349 @init { 8349 @init {
8350 int stackSize = keepStackSize(); 8350 int stackSize = keepStackSize();
8351 } 8351 }
8352: 8352:
8353 rule__GenerationTask__Group_3_11__1__Impl 8353 rule__GenerationTask__Group__3__Impl
8354 rule__GenerationTask__Group_3_11__2 8354 rule__GenerationTask__Group__4
8355; 8355;
8356finally { 8356finally {
8357 restoreStackSize(stackSize); 8357 restoreStackSize(stackSize);
8358} 8358}
8359 8359
8360rule__GenerationTask__Group_3_11__1__Impl 8360rule__GenerationTask__Group__3__Impl
8361 @init { 8361 @init {
8362 int stackSize = keepStackSize(); 8362 int stackSize = keepStackSize();
8363 } 8363 }
8364: 8364:
8365( 8365(
8366 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_11_1()); } 8366 { before(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); }
8367 '=' 8367 (rule__GenerationTask__UnorderedGroup_3)
8368 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_11_1()); } 8368 { after(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); }
8369) 8369)
8370; 8370;
8371finally { 8371finally {
8372 restoreStackSize(stackSize); 8372 restoreStackSize(stackSize);
8373} 8373}
8374 8374
8375rule__GenerationTask__Group_3_11__2 8375rule__GenerationTask__Group__4
8376 @init { 8376 @init {
8377 int stackSize = keepStackSize(); 8377 int stackSize = keepStackSize();
8378 } 8378 }
8379: 8379:
8380 rule__GenerationTask__Group_3_11__2__Impl 8380 rule__GenerationTask__Group__4__Impl
8381; 8381;
8382finally { 8382finally {
8383 restoreStackSize(stackSize); 8383 restoreStackSize(stackSize);
8384} 8384}
8385 8385
8386rule__GenerationTask__Group_3_11__2__Impl 8386rule__GenerationTask__Group__4__Impl
8387 @init { 8387 @init {
8388 int stackSize = keepStackSize(); 8388 int stackSize = keepStackSize();
8389 } 8389 }
8390: 8390:
8391( 8391(
8392 { before(grammarAccess.getGenerationTaskAccess().getTagetFolderAssignment_3_11_2()); } 8392 { before(grammarAccess.getGenerationTaskAccess().getRightCurlyBracketKeyword_4()); }
8393 (rule__GenerationTask__TagetFolderAssignment_3_11_2) 8393 '}'
8394 { after(grammarAccess.getGenerationTaskAccess().getTagetFolderAssignment_3_11_2()); } 8394 { after(grammarAccess.getGenerationTaskAccess().getRightCurlyBracketKeyword_4()); }
8395) 8395)
8396; 8396;
8397finally { 8397finally {
8398 restoreStackSize(stackSize); 8398 restoreStackSize(stackSize);
8399} 8399}
8400 8400
8401 8401
8402rule__GenerationTask__UnorderedGroup_3 8402rule__GenerationTask__Group_3_0__0
8403 @init { 8403 @init {
8404 int stackSize = keepStackSize(); 8404 int stackSize = keepStackSize();
8405 getUnorderedGroupHelper().enter(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); 8405 }
8406 } 8406:
8407: 8407 rule__GenerationTask__Group_3_0__0__Impl
8408 rule__GenerationTask__UnorderedGroup_3__0 8408 rule__GenerationTask__Group_3_0__1
8409 ? 8409;
8410; 8410finally {
8411finally { 8411 restoreStackSize(stackSize);
8412 getUnorderedGroupHelper().leave(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); 8412}
8413 restoreStackSize(stackSize); 8413
8414} 8414rule__GenerationTask__Group_3_0__0__Impl
8415 8415 @init {
8416rule__GenerationTask__UnorderedGroup_3__Impl 8416 int stackSize = keepStackSize();
8417 @init { 8417 }
8418 int stackSize = keepStackSize(); 8418:
8419 boolean selected = false; 8419(
8420 } 8420 { before(grammarAccess.getGenerationTaskAccess().getMetamodelKeyword_3_0_0()); }
8421: 8421 'metamodel'
8422 ( 8422 { after(grammarAccess.getGenerationTaskAccess().getMetamodelKeyword_3_0_0()); }
8423 ( 8423)
8424 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 0)}?=>( 8424;
8425 { 8425finally {
8426 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 0); 8426 restoreStackSize(stackSize);
8427 } 8427}
8428 { 8428
8429 selected = true; 8429rule__GenerationTask__Group_3_0__1
8430 } 8430 @init {
8431 ( 8431 int stackSize = keepStackSize();
8432 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_0()); } 8432 }
8433 (rule__GenerationTask__Group_3_0__0) 8433:
8434 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_0()); } 8434 rule__GenerationTask__Group_3_0__1__Impl
8435 ) 8435 rule__GenerationTask__Group_3_0__2
8436 ) 8436;
8437 )| 8437finally {
8438 ( 8438 restoreStackSize(stackSize);
8439 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 1)}?=>( 8439}
8440 { 8440
8441 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 1); 8441rule__GenerationTask__Group_3_0__1__Impl
8442 } 8442 @init {
8443 { 8443 int stackSize = keepStackSize();
8444 selected = true; 8444 }
8445 } 8445:
8446 ( 8446(
8447 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_1()); } 8447 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_0_1()); }
8448 (rule__GenerationTask__Group_3_1__0) 8448 '='
8449 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_1()); } 8449 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_0_1()); }
8450 ) 8450)
8451 ) 8451;
8452 )| 8452finally {
8453 ( 8453 restoreStackSize(stackSize);
8454 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 2)}?=>( 8454}
8455 { 8455
8456 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 2); 8456rule__GenerationTask__Group_3_0__2
8457 } 8457 @init {
8458 { 8458 int stackSize = keepStackSize();
8459 selected = true; 8459 }
8460 } 8460:
8461 ( 8461 rule__GenerationTask__Group_3_0__2__Impl
8462 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_2()); } 8462;
8463 (rule__GenerationTask__Group_3_2__0) 8463finally {
8464 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_2()); } 8464 restoreStackSize(stackSize);
8465 ) 8465}
8466 ) 8466
8467 )| 8467rule__GenerationTask__Group_3_0__2__Impl
8468 ( 8468 @init {
8469 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 3)}?=>( 8469 int stackSize = keepStackSize();
8470 { 8470 }
8471 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 3); 8471:
8472 } 8472(
8473 { 8473 { before(grammarAccess.getGenerationTaskAccess().getMetamodelAssignment_3_0_2()); }
8474 selected = true; 8474 (rule__GenerationTask__MetamodelAssignment_3_0_2)
8475 } 8475 { after(grammarAccess.getGenerationTaskAccess().getMetamodelAssignment_3_0_2()); }
8476 ( 8476)
8477 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_3()); } 8477;
8478 (rule__GenerationTask__Group_3_3__0) 8478finally {
8479 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_3()); } 8479 restoreStackSize(stackSize);
8480 ) 8480}
8481 ) 8481
8482 )| 8482
8483 ( 8483rule__GenerationTask__Group_3_1__0
8484 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 4)}?=>( 8484 @init {
8485 { 8485 int stackSize = keepStackSize();
8486 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 4); 8486 }
8487 } 8487:
8488 { 8488 rule__GenerationTask__Group_3_1__0__Impl
8489 selected = true; 8489 rule__GenerationTask__Group_3_1__1
8490 } 8490;
8491 ( 8491finally {
8492 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_4()); } 8492 restoreStackSize(stackSize);
8493 (rule__GenerationTask__Group_3_4__0) 8493}
8494 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_4()); } 8494
8495 ) 8495rule__GenerationTask__Group_3_1__0__Impl
8496 ) 8496 @init {
8497 )| 8497 int stackSize = keepStackSize();
8498 ( 8498 }
8499 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 5)}?=>( 8499:
8500 { 8500(
8501 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 5); 8501 { before(grammarAccess.getGenerationTaskAccess().getPartialModelKeyword_3_1_0()); }
8502 } 8502 'partial-model'
8503 { 8503 { after(grammarAccess.getGenerationTaskAccess().getPartialModelKeyword_3_1_0()); }
8504 selected = true; 8504)
8505 } 8505;
8506 ( 8506finally {
8507 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_5()); } 8507 restoreStackSize(stackSize);
8508 (rule__GenerationTask__Group_3_5__0) 8508}
8509 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_5()); } 8509
8510 ) 8510rule__GenerationTask__Group_3_1__1
8511 ) 8511 @init {
8512 )| 8512 int stackSize = keepStackSize();
8513 ( 8513 }
8514 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 6)}?=>( 8514:
8515 { 8515 rule__GenerationTask__Group_3_1__1__Impl
8516 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 6); 8516 rule__GenerationTask__Group_3_1__2
8517 } 8517;
8518 { 8518finally {
8519 selected = true; 8519 restoreStackSize(stackSize);
8520 } 8520}
8521 ( 8521
8522 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_6()); } 8522rule__GenerationTask__Group_3_1__1__Impl
8523 (rule__GenerationTask__Group_3_6__0) 8523 @init {
8524 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_6()); } 8524 int stackSize = keepStackSize();
8525 ) 8525 }
8526 ) 8526:
8527 )| 8527(
8528 ( 8528 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_1_1()); }
8529 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 7)}?=>( 8529 '='
8530 { 8530 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_1_1()); }
8531 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 7); 8531)
8532 } 8532;
8533 { 8533finally {
8534 selected = true; 8534 restoreStackSize(stackSize);
8535 } 8535}
8536 ( 8536
8537 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_7()); } 8537rule__GenerationTask__Group_3_1__2
8538 (rule__GenerationTask__Group_3_7__0) 8538 @init {
8539 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_7()); } 8539 int stackSize = keepStackSize();
8540 ) 8540 }
8541 ) 8541:
8542 )| 8542 rule__GenerationTask__Group_3_1__2__Impl
8543 ( 8543;
8544 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 8)}?=>( 8544finally {
8545 { 8545 restoreStackSize(stackSize);
8546 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 8); 8546}
8547 } 8547
8548 { 8548rule__GenerationTask__Group_3_1__2__Impl
8549 selected = true; 8549 @init {
8550 } 8550 int stackSize = keepStackSize();
8551 ( 8551 }
8552 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_8()); } 8552:
8553 (rule__GenerationTask__Group_3_8__0) 8553(
8554 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_8()); } 8554 { before(grammarAccess.getGenerationTaskAccess().getPartialModelAssignment_3_1_2()); }
8555 ) 8555 (rule__GenerationTask__PartialModelAssignment_3_1_2)
8556 ) 8556 { after(grammarAccess.getGenerationTaskAccess().getPartialModelAssignment_3_1_2()); }
8557 )| 8557)
8558 ( 8558;
8559 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 9)}?=>( 8559finally {
8560 { 8560 restoreStackSize(stackSize);
8561 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 9); 8561}
8562 } 8562
8563 { 8563
8564 selected = true; 8564rule__GenerationTask__Group_3_2__0
8565 } 8565 @init {
8566 ( 8566 int stackSize = keepStackSize();
8567 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_9()); } 8567 }
8568 (rule__GenerationTask__Group_3_9__0) 8568:
8569 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_9()); } 8569 rule__GenerationTask__Group_3_2__0__Impl
8570 ) 8570 rule__GenerationTask__Group_3_2__1
8571 ) 8571;
8572 )| 8572finally {
8573 ( 8573 restoreStackSize(stackSize);
8574 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 10)}?=>( 8574}
8575 { 8575
8576 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 10); 8576rule__GenerationTask__Group_3_2__0__Impl
8577 } 8577 @init {
8578 { 8578 int stackSize = keepStackSize();
8579 selected = true; 8579 }
8580 } 8580:
8581 ( 8581(
8582 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_10()); } 8582 { before(grammarAccess.getGenerationTaskAccess().getConstraintsKeyword_3_2_0()); }
8583 (rule__GenerationTask__Group_3_10__0) 8583 'constraints'
8584 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_10()); } 8584 { after(grammarAccess.getGenerationTaskAccess().getConstraintsKeyword_3_2_0()); }
8585 ) 8585)
8586 ) 8586;
8587 )| 8587finally {
8588 ( 8588 restoreStackSize(stackSize);
8589 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 11)}?=>( 8589}
8590 { 8590
8591 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 11); 8591rule__GenerationTask__Group_3_2__1
8592 } 8592 @init {
8593 { 8593 int stackSize = keepStackSize();
8594 selected = true; 8594 }
8595 } 8595:
8596 ( 8596 rule__GenerationTask__Group_3_2__1__Impl
8597 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_11()); } 8597 rule__GenerationTask__Group_3_2__2
8598 (rule__GenerationTask__Group_3_11__0) 8598;
8599 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_11()); } 8599finally {
8600 ) 8600 restoreStackSize(stackSize);
8601 ) 8601}
8602 ) 8602
8603 ) 8603rule__GenerationTask__Group_3_2__1__Impl
8604; 8604 @init {
8605finally { 8605 int stackSize = keepStackSize();
8606 if (selected) 8606 }
8607 getUnorderedGroupHelper().returnFromSelection(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); 8607:
8608 restoreStackSize(stackSize); 8608(
8609} 8609 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_2_1()); }
8610 8610 '='
8611rule__GenerationTask__UnorderedGroup_3__0 8611 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_2_1()); }
8612 @init { 8612)
8613 int stackSize = keepStackSize(); 8613;
8614 } 8614finally {
8615: 8615 restoreStackSize(stackSize);
8616 rule__GenerationTask__UnorderedGroup_3__Impl 8616}
8617 rule__GenerationTask__UnorderedGroup_3__1? 8617
8618; 8618rule__GenerationTask__Group_3_2__2
8619finally { 8619 @init {
8620 restoreStackSize(stackSize); 8620 int stackSize = keepStackSize();
8621} 8621 }
8622 8622:
8623rule__GenerationTask__UnorderedGroup_3__1 8623 rule__GenerationTask__Group_3_2__2__Impl
8624 @init { 8624;
8625 int stackSize = keepStackSize(); 8625finally {
8626 } 8626 restoreStackSize(stackSize);
8627: 8627}
8628 rule__GenerationTask__UnorderedGroup_3__Impl 8628
8629 rule__GenerationTask__UnorderedGroup_3__2? 8629rule__GenerationTask__Group_3_2__2__Impl
8630; 8630 @init {
8631finally { 8631 int stackSize = keepStackSize();
8632 restoreStackSize(stackSize); 8632 }
8633} 8633:
8634 8634(
8635rule__GenerationTask__UnorderedGroup_3__2 8635 { before(grammarAccess.getGenerationTaskAccess().getPatternsAssignment_3_2_2()); }
8636 @init { 8636 (rule__GenerationTask__PatternsAssignment_3_2_2)
8637 int stackSize = keepStackSize(); 8637 { after(grammarAccess.getGenerationTaskAccess().getPatternsAssignment_3_2_2()); }
8638 } 8638)
8639: 8639;
8640 rule__GenerationTask__UnorderedGroup_3__Impl 8640finally {
8641 rule__GenerationTask__UnorderedGroup_3__3? 8641 restoreStackSize(stackSize);
8642; 8642}
8643finally { 8643
8644 restoreStackSize(stackSize); 8644
8645} 8645rule__GenerationTask__Group_3_3__0
8646 8646 @init {
8647rule__GenerationTask__UnorderedGroup_3__3 8647 int stackSize = keepStackSize();
8648 @init { 8648 }
8649 int stackSize = keepStackSize(); 8649:
8650 } 8650 rule__GenerationTask__Group_3_3__0__Impl
8651: 8651 rule__GenerationTask__Group_3_3__1
8652 rule__GenerationTask__UnorderedGroup_3__Impl 8652;
8653 rule__GenerationTask__UnorderedGroup_3__4? 8653finally {
8654; 8654 restoreStackSize(stackSize);
8655finally { 8655}
8656 restoreStackSize(stackSize); 8656
8657} 8657rule__GenerationTask__Group_3_3__0__Impl
8658 8658 @init {
8659rule__GenerationTask__UnorderedGroup_3__4 8659 int stackSize = keepStackSize();
8660 @init { 8660 }
8661 int stackSize = keepStackSize(); 8661:
8662 } 8662(
8663: 8663 { before(grammarAccess.getGenerationTaskAccess().getObjectivesKeyword_3_3_0()); }
8664 rule__GenerationTask__UnorderedGroup_3__Impl 8664 'objectives'
8665 rule__GenerationTask__UnorderedGroup_3__5? 8665 { after(grammarAccess.getGenerationTaskAccess().getObjectivesKeyword_3_3_0()); }
8666; 8666)
8667finally { 8667;
8668 restoreStackSize(stackSize); 8668finally {
8669} 8669 restoreStackSize(stackSize);
8670 8670}
8671rule__GenerationTask__UnorderedGroup_3__5 8671
8672 @init { 8672rule__GenerationTask__Group_3_3__1
8673 int stackSize = keepStackSize(); 8673 @init {
8674 } 8674 int stackSize = keepStackSize();
8675: 8675 }
8676 rule__GenerationTask__UnorderedGroup_3__Impl 8676:
8677 rule__GenerationTask__UnorderedGroup_3__6? 8677 rule__GenerationTask__Group_3_3__1__Impl
8678; 8678 rule__GenerationTask__Group_3_3__2
8679finally { 8679;
8680 restoreStackSize(stackSize); 8680finally {
8681} 8681 restoreStackSize(stackSize);
8682 8682}
8683rule__GenerationTask__UnorderedGroup_3__6 8683
8684 @init { 8684rule__GenerationTask__Group_3_3__1__Impl
8685 int stackSize = keepStackSize(); 8685 @init {
8686 } 8686 int stackSize = keepStackSize();
8687: 8687 }
8688 rule__GenerationTask__UnorderedGroup_3__Impl 8688:
8689 rule__GenerationTask__UnorderedGroup_3__7? 8689(
8690; 8690 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_3_1()); }
8691finally { 8691 '='
8692 restoreStackSize(stackSize); 8692 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_3_1()); }
8693} 8693)
8694 8694;
8695rule__GenerationTask__UnorderedGroup_3__7 8695finally {
8696 @init { 8696 restoreStackSize(stackSize);
8697 int stackSize = keepStackSize(); 8697}
8698 } 8698
8699: 8699rule__GenerationTask__Group_3_3__2
8700 rule__GenerationTask__UnorderedGroup_3__Impl 8700 @init {
8701 rule__GenerationTask__UnorderedGroup_3__8? 8701 int stackSize = keepStackSize();
8702; 8702 }
8703finally { 8703:
8704 restoreStackSize(stackSize); 8704 rule__GenerationTask__Group_3_3__2__Impl
8705} 8705;
8706 8706finally {
8707rule__GenerationTask__UnorderedGroup_3__8 8707 restoreStackSize(stackSize);
8708 @init { 8708}
8709 int stackSize = keepStackSize(); 8709
8710 } 8710rule__GenerationTask__Group_3_3__2__Impl
8711: 8711 @init {
8712 rule__GenerationTask__UnorderedGroup_3__Impl 8712 int stackSize = keepStackSize();
8713 rule__GenerationTask__UnorderedGroup_3__9? 8713 }
8714; 8714:
8715finally { 8715(
8716 restoreStackSize(stackSize); 8716 { before(grammarAccess.getGenerationTaskAccess().getObjectivesAssignment_3_3_2()); }
8717} 8717 (rule__GenerationTask__ObjectivesAssignment_3_3_2)
8718 8718 { after(grammarAccess.getGenerationTaskAccess().getObjectivesAssignment_3_3_2()); }
8719rule__GenerationTask__UnorderedGroup_3__9 8719)
8720 @init { 8720;
8721 int stackSize = keepStackSize(); 8721finally {
8722 } 8722 restoreStackSize(stackSize);
8723: 8723}
8724 rule__GenerationTask__UnorderedGroup_3__Impl 8724
8725 rule__GenerationTask__UnorderedGroup_3__10? 8725
8726; 8726rule__GenerationTask__Group_3_4__0
8727finally { 8727 @init {
8728 restoreStackSize(stackSize); 8728 int stackSize = keepStackSize();
8729} 8729 }
8730 8730:
8731rule__GenerationTask__UnorderedGroup_3__10 8731 rule__GenerationTask__Group_3_4__0__Impl
8732 @init { 8732 rule__GenerationTask__Group_3_4__1
8733 int stackSize = keepStackSize(); 8733;
8734 } 8734finally {
8735: 8735 restoreStackSize(stackSize);
8736 rule__GenerationTask__UnorderedGroup_3__Impl 8736}
8737 rule__GenerationTask__UnorderedGroup_3__11? 8737
8738; 8738rule__GenerationTask__Group_3_4__0__Impl
8739finally { 8739 @init {
8740 restoreStackSize(stackSize); 8740 int stackSize = keepStackSize();
8741} 8741 }
8742 8742:
8743rule__GenerationTask__UnorderedGroup_3__11 8743(
8744 @init { 8744 { before(grammarAccess.getGenerationTaskAccess().getScopeKeyword_3_4_0()); }
8745 int stackSize = keepStackSize(); 8745 'scope'
8746 } 8746 { after(grammarAccess.getGenerationTaskAccess().getScopeKeyword_3_4_0()); }
8747: 8747)
8748 rule__GenerationTask__UnorderedGroup_3__Impl 8748;
8749; 8749finally {
8750finally { 8750 restoreStackSize(stackSize);
8751 restoreStackSize(stackSize); 8751}
8752} 8752
8753 8753rule__GenerationTask__Group_3_4__1
8754 8754 @init {
8755rule__ConfigurationScript__ImportsAssignment_0 8755 int stackSize = keepStackSize();
8756 @init { 8756 }
8757 int stackSize = keepStackSize(); 8757:
8758 } 8758 rule__GenerationTask__Group_3_4__1__Impl
8759: 8759 rule__GenerationTask__Group_3_4__2
8760 ( 8760;
8761 { before(grammarAccess.getConfigurationScriptAccess().getImportsImportParserRuleCall_0_0()); } 8761finally {
8762 ruleImport 8762 restoreStackSize(stackSize);
8763 { after(grammarAccess.getConfigurationScriptAccess().getImportsImportParserRuleCall_0_0()); } 8763}
8764 ) 8764
8765; 8765rule__GenerationTask__Group_3_4__1__Impl
8766finally { 8766 @init {
8767 restoreStackSize(stackSize); 8767 int stackSize = keepStackSize();
8768} 8768 }
8769 8769:
8770rule__ConfigurationScript__CommandsAssignment_1 8770(
8771 @init { 8771 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_4_1()); }
8772 int stackSize = keepStackSize(); 8772 '='
8773 } 8773 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_4_1()); }
8774: 8774)
8775 ( 8775;
8776 { before(grammarAccess.getConfigurationScriptAccess().getCommandsCommandParserRuleCall_1_0()); } 8776finally {
8777 ruleCommand 8777 restoreStackSize(stackSize);
8778 { after(grammarAccess.getConfigurationScriptAccess().getCommandsCommandParserRuleCall_1_0()); } 8778}
8779 ) 8779
8780; 8780rule__GenerationTask__Group_3_4__2
8781finally { 8781 @init {
8782 restoreStackSize(stackSize); 8782 int stackSize = keepStackSize();
8783} 8783 }
8784 8784:
8785rule__EPackageImport__ImportedPackageAssignment_2 8785 rule__GenerationTask__Group_3_4__2__Impl
8786 @init { 8786;
8787 int stackSize = keepStackSize(); 8787finally {
8788 } 8788 restoreStackSize(stackSize);
8789: 8789}
8790 ( 8790
8791 { before(grammarAccess.getEPackageImportAccess().getImportedPackageEPackageCrossReference_2_0()); } 8791rule__GenerationTask__Group_3_4__2__Impl
8792 ( 8792 @init {
8793 { before(grammarAccess.getEPackageImportAccess().getImportedPackageEPackageSTRINGTerminalRuleCall_2_0_1()); } 8793 int stackSize = keepStackSize();
8794 RULE_STRING 8794 }
8795 { after(grammarAccess.getEPackageImportAccess().getImportedPackageEPackageSTRINGTerminalRuleCall_2_0_1()); } 8795:
8796 ) 8796(
8797 { after(grammarAccess.getEPackageImportAccess().getImportedPackageEPackageCrossReference_2_0()); } 8797 { before(grammarAccess.getGenerationTaskAccess().getScopeAssignment_3_4_2()); }
8798 ) 8798 (rule__GenerationTask__ScopeAssignment_3_4_2)
8799; 8799 { after(grammarAccess.getGenerationTaskAccess().getScopeAssignment_3_4_2()); }
8800finally { 8800)
8801 restoreStackSize(stackSize); 8801;
8802} 8802finally {
8803 8803 restoreStackSize(stackSize);
8804rule__ViatraImport__ImportedViatraAssignment_2 8804}
8805 @init { 8805
8806 int stackSize = keepStackSize(); 8806
8807 } 8807rule__GenerationTask__Group_3_5__0
8808: 8808 @init {
8809 ( 8809 int stackSize = keepStackSize();
8810 { before(grammarAccess.getViatraImportAccess().getImportedViatraPatternModelCrossReference_2_0()); } 8810 }
8811 ( 8811:
8812 { before(grammarAccess.getViatraImportAccess().getImportedViatraPatternModelSTRINGTerminalRuleCall_2_0_1()); } 8812 rule__GenerationTask__Group_3_5__0__Impl
8813 RULE_STRING 8813 rule__GenerationTask__Group_3_5__1
8814 { after(grammarAccess.getViatraImportAccess().getImportedViatraPatternModelSTRINGTerminalRuleCall_2_0_1()); } 8814;
8815 ) 8815finally {
8816 { after(grammarAccess.getViatraImportAccess().getImportedViatraPatternModelCrossReference_2_0()); } 8816 restoreStackSize(stackSize);
8817 ) 8817}
8818; 8818
8819finally { 8819rule__GenerationTask__Group_3_5__0__Impl
8820 restoreStackSize(stackSize); 8820 @init {
8821} 8821 int stackSize = keepStackSize();
8822 8822 }
8823rule__FileSpecification__PathAssignment 8823:
8824 @init { 8824(
8825 int stackSize = keepStackSize(); 8825 { before(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedAssignment_3_5_0()); }
8826 } 8826 (rule__GenerationTask__NumberSpecifiedAssignment_3_5_0)
8827: 8827 { after(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedAssignment_3_5_0()); }
8828 ( 8828)
8829 { before(grammarAccess.getFileSpecificationAccess().getPathSTRINGTerminalRuleCall_0()); } 8829;
8830 RULE_STRING 8830finally {
8831 { after(grammarAccess.getFileSpecificationAccess().getPathSTRINGTerminalRuleCall_0()); } 8831 restoreStackSize(stackSize);
8832 ) 8832}
8833; 8833
8834finally { 8834rule__GenerationTask__Group_3_5__1
8835 restoreStackSize(stackSize); 8835 @init {
8836} 8836 int stackSize = keepStackSize();
8837 8837 }
8838rule__FileDeclaration__NameAssignment_1 8838:
8839 @init { 8839 rule__GenerationTask__Group_3_5__1__Impl
8840 int stackSize = keepStackSize(); 8840 rule__GenerationTask__Group_3_5__2
8841 } 8841;
8842: 8842finally {
8843 ( 8843 restoreStackSize(stackSize);
8844 { before(grammarAccess.getFileDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 8844}
8845 RULE_ID 8845
8846 { after(grammarAccess.getFileDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 8846rule__GenerationTask__Group_3_5__1__Impl
8847 ) 8847 @init {
8848; 8848 int stackSize = keepStackSize();
8849finally { 8849 }
8850 restoreStackSize(stackSize); 8850:
8851} 8851(
8852 8852 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_5_1()); }
8853rule__FileDeclaration__SpecificationAssignment_3 8853 '='
8854 @init { 8854 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_5_1()); }
8855 int stackSize = keepStackSize(); 8855)
8856 } 8856;
8857: 8857finally {
8858 ( 8858 restoreStackSize(stackSize);
8859 { before(grammarAccess.getFileDeclarationAccess().getSpecificationFileSpecificationParserRuleCall_3_0()); } 8859}
8860 ruleFileSpecification 8860
8861 { after(grammarAccess.getFileDeclarationAccess().getSpecificationFileSpecificationParserRuleCall_3_0()); } 8861rule__GenerationTask__Group_3_5__2
8862 ) 8862 @init {
8863; 8863 int stackSize = keepStackSize();
8864finally { 8864 }
8865 restoreStackSize(stackSize); 8865:
8866} 8866 rule__GenerationTask__Group_3_5__2__Impl
8867 8867;
8868rule__FileReference__ReferredAssignment 8868finally {
8869 @init { 8869 restoreStackSize(stackSize);
8870 int stackSize = keepStackSize(); 8870}
8871 } 8871
8872: 8872rule__GenerationTask__Group_3_5__2__Impl
8873 ( 8873 @init {
8874 { before(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationCrossReference_0()); } 8874 int stackSize = keepStackSize();
8875 ( 8875 }
8876 { before(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationIDTerminalRuleCall_0_1()); } 8876:
8877 RULE_ID 8877(
8878 { after(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationIDTerminalRuleCall_0_1()); } 8878 { before(grammarAccess.getGenerationTaskAccess().getNumberAssignment_3_5_2()); }
8879 ) 8879 (rule__GenerationTask__NumberAssignment_3_5_2)
8880 { after(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationCrossReference_0()); } 8880 { after(grammarAccess.getGenerationTaskAccess().getNumberAssignment_3_5_2()); }
8881 ) 8881)
8882; 8882;
8883finally { 8883finally {
8884 restoreStackSize(stackSize); 8884 restoreStackSize(stackSize);
8885} 8885}
8886 8886
8887rule__MetamodelSpecification__EntriesAssignment_1 8887
8888 @init { 8888rule__GenerationTask__Group_3_6__0
8889 int stackSize = keepStackSize(); 8889 @init {
8890 } 8890 int stackSize = keepStackSize();
8891: 8891 }
8892 ( 8892:
8893 { before(grammarAccess.getMetamodelSpecificationAccess().getEntriesMetamodelEntryParserRuleCall_1_0()); } 8893 rule__GenerationTask__Group_3_6__0__Impl
8894 ruleMetamodelEntry 8894 rule__GenerationTask__Group_3_6__1
8895 { after(grammarAccess.getMetamodelSpecificationAccess().getEntriesMetamodelEntryParserRuleCall_1_0()); } 8895;
8896 ) 8896finally {
8897; 8897 restoreStackSize(stackSize);
8898finally { 8898}
8899 restoreStackSize(stackSize); 8899
8900} 8900rule__GenerationTask__Group_3_6__0__Impl
8901 8901 @init {
8902rule__MetamodelSpecification__EntriesAssignment_2_1 8902 int stackSize = keepStackSize();
8903 @init { 8903 }
8904 int stackSize = keepStackSize(); 8904:
8905 } 8905(
8906: 8906 { before(grammarAccess.getGenerationTaskAccess().getRunSpecifiedAssignment_3_6_0()); }
8907 ( 8907 (rule__GenerationTask__RunSpecifiedAssignment_3_6_0)
8908 { before(grammarAccess.getMetamodelSpecificationAccess().getEntriesMetamodelEntryParserRuleCall_2_1_0()); } 8908 { after(grammarAccess.getGenerationTaskAccess().getRunSpecifiedAssignment_3_6_0()); }
8909 ruleMetamodelEntry 8909)
8910 { after(grammarAccess.getMetamodelSpecificationAccess().getEntriesMetamodelEntryParserRuleCall_2_1_0()); } 8910;
8911 ) 8911finally {
8912; 8912 restoreStackSize(stackSize);
8913finally { 8913}
8914 restoreStackSize(stackSize); 8914
8915} 8915rule__GenerationTask__Group_3_6__1
8916 8916 @init {
8917rule__AllPackageEntry__PackageAssignment_1 8917 int stackSize = keepStackSize();
8918 @init { 8918 }
8919 int stackSize = keepStackSize(); 8919:
8920 } 8920 rule__GenerationTask__Group_3_6__1__Impl
8921: 8921 rule__GenerationTask__Group_3_6__2
8922 ( 8922;
8923 { before(grammarAccess.getAllPackageEntryAccess().getPackageEPackageCrossReference_1_0()); } 8923finally {
8924 ( 8924 restoreStackSize(stackSize);
8925 { before(grammarAccess.getAllPackageEntryAccess().getPackageEPackageQualifiedNameParserRuleCall_1_0_1()); } 8925}
8926 ruleQualifiedName 8926
8927 { after(grammarAccess.getAllPackageEntryAccess().getPackageEPackageQualifiedNameParserRuleCall_1_0_1()); } 8927rule__GenerationTask__Group_3_6__1__Impl
8928 ) 8928 @init {
8929 { after(grammarAccess.getAllPackageEntryAccess().getPackageEPackageCrossReference_1_0()); } 8929 int stackSize = keepStackSize();
8930 ) 8930 }
8931; 8931:
8932finally { 8932(
8933 restoreStackSize(stackSize); 8933 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_6_1()); }
8934} 8934 '='
8935 8935 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_6_1()); }
8936rule__AllPackageEntry__ExclusionAssignment_2_2 8936)
8937 @init { 8937;
8938 int stackSize = keepStackSize(); 8938finally {
8939 } 8939 restoreStackSize(stackSize);
8940: 8940}
8941 ( 8941
8942 { before(grammarAccess.getAllPackageEntryAccess().getExclusionMetamodelElementParserRuleCall_2_2_0()); } 8942rule__GenerationTask__Group_3_6__2
8943 ruleMetamodelElement 8943 @init {
8944 { after(grammarAccess.getAllPackageEntryAccess().getExclusionMetamodelElementParserRuleCall_2_2_0()); } 8944 int stackSize = keepStackSize();
8945 ) 8945 }
8946; 8946:
8947finally { 8947 rule__GenerationTask__Group_3_6__2__Impl
8948 restoreStackSize(stackSize); 8948;
8949} 8949finally {
8950 8950 restoreStackSize(stackSize);
8951rule__AllPackageEntry__ExclusionAssignment_2_3_1 8951}
8952 @init { 8952
8953 int stackSize = keepStackSize(); 8953rule__GenerationTask__Group_3_6__2__Impl
8954 } 8954 @init {
8955: 8955 int stackSize = keepStackSize();
8956 ( 8956 }
8957 { before(grammarAccess.getAllPackageEntryAccess().getExclusionMetamodelElementParserRuleCall_2_3_1_0()); } 8957:
8958 ruleMetamodelElement 8958(
8959 { after(grammarAccess.getAllPackageEntryAccess().getExclusionMetamodelElementParserRuleCall_2_3_1_0()); } 8959 { before(grammarAccess.getGenerationTaskAccess().getRunsAssignment_3_6_2()); }
8960 ) 8960 (rule__GenerationTask__RunsAssignment_3_6_2)
8961; 8961 { after(grammarAccess.getGenerationTaskAccess().getRunsAssignment_3_6_2()); }
8962finally { 8962)
8963 restoreStackSize(stackSize); 8963;
8964} 8964finally {
8965 8965 restoreStackSize(stackSize);
8966rule__MetamodelElement__PackageAssignment_0_0 8966}
8967 @init { 8967
8968 int stackSize = keepStackSize(); 8968
8969 } 8969rule__GenerationTask__Group_3_7__0
8970: 8970 @init {
8971 ( 8971 int stackSize = keepStackSize();
8972 { before(grammarAccess.getMetamodelElementAccess().getPackageEPackageCrossReference_0_0_0()); } 8972 }
8973 ( 8973:
8974 { before(grammarAccess.getMetamodelElementAccess().getPackageEPackageQualifiedNameParserRuleCall_0_0_0_1()); } 8974 rule__GenerationTask__Group_3_7__0__Impl
8975 ruleQualifiedName 8975 rule__GenerationTask__Group_3_7__1
8976 { after(grammarAccess.getMetamodelElementAccess().getPackageEPackageQualifiedNameParserRuleCall_0_0_0_1()); } 8976;
8977 ) 8977finally {
8978 { after(grammarAccess.getMetamodelElementAccess().getPackageEPackageCrossReference_0_0_0()); } 8978 restoreStackSize(stackSize);
8979 ) 8979}
8980; 8980
8981finally { 8981rule__GenerationTask__Group_3_7__0__Impl
8982 restoreStackSize(stackSize); 8982 @init {
8983} 8983 int stackSize = keepStackSize();
8984 8984 }
8985rule__MetamodelElement__ClassifierAssignment_1 8985:
8986 @init { 8986(
8987 int stackSize = keepStackSize(); 8987 { before(grammarAccess.getGenerationTaskAccess().getSolverKeyword_3_7_0()); }
8988 } 8988 'solver'
8989: 8989 { after(grammarAccess.getGenerationTaskAccess().getSolverKeyword_3_7_0()); }
8990 ( 8990)
8991 { before(grammarAccess.getMetamodelElementAccess().getClassifierEClassifierCrossReference_1_0()); } 8991;
8992 ( 8992finally {
8993 { before(grammarAccess.getMetamodelElementAccess().getClassifierEClassifierIDTerminalRuleCall_1_0_1()); } 8993 restoreStackSize(stackSize);
8994 RULE_ID 8994}
8995 { after(grammarAccess.getMetamodelElementAccess().getClassifierEClassifierIDTerminalRuleCall_1_0_1()); } 8995
8996 ) 8996rule__GenerationTask__Group_3_7__1
8997 { after(grammarAccess.getMetamodelElementAccess().getClassifierEClassifierCrossReference_1_0()); } 8997 @init {
8998 ) 8998 int stackSize = keepStackSize();
8999; 8999 }
9000finally { 9000:
9001 restoreStackSize(stackSize); 9001 rule__GenerationTask__Group_3_7__1__Impl
9002} 9002 rule__GenerationTask__Group_3_7__2
9003 9003;
9004rule__MetamodelElement__FeatureAssignment_2_1 9004finally {
9005 @init { 9005 restoreStackSize(stackSize);
9006 int stackSize = keepStackSize(); 9006}
9007 } 9007
9008: 9008rule__GenerationTask__Group_3_7__1__Impl
9009 ( 9009 @init {
9010 { before(grammarAccess.getMetamodelElementAccess().getFeatureENamedElementCrossReference_2_1_0()); } 9010 int stackSize = keepStackSize();
9011 ( 9011 }
9012 { before(grammarAccess.getMetamodelElementAccess().getFeatureENamedElementIDTerminalRuleCall_2_1_0_1()); } 9012:
9013 RULE_ID 9013(
9014 { after(grammarAccess.getMetamodelElementAccess().getFeatureENamedElementIDTerminalRuleCall_2_1_0_1()); } 9014 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_7_1()); }
9015 ) 9015 '='
9016 { after(grammarAccess.getMetamodelElementAccess().getFeatureENamedElementCrossReference_2_1_0()); } 9016 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_7_1()); }
9017 ) 9017)
9018; 9018;
9019finally { 9019finally {
9020 restoreStackSize(stackSize); 9020 restoreStackSize(stackSize);
9021} 9021}
9022 9022
9023rule__MetamodelDeclaration__NameAssignment_1 9023rule__GenerationTask__Group_3_7__2
9024 @init { 9024 @init {
9025 int stackSize = keepStackSize(); 9025 int stackSize = keepStackSize();
9026 } 9026 }
9027: 9027:
9028 ( 9028 rule__GenerationTask__Group_3_7__2__Impl
9029 { before(grammarAccess.getMetamodelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 9029;
9030 RULE_ID 9030finally {
9031 { after(grammarAccess.getMetamodelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 9031 restoreStackSize(stackSize);
9032 ) 9032}
9033; 9033
9034finally { 9034rule__GenerationTask__Group_3_7__2__Impl
9035 restoreStackSize(stackSize); 9035 @init {
9036} 9036 int stackSize = keepStackSize();
9037 9037 }
9038rule__MetamodelDeclaration__SpecificationAssignment_2 9038:
9039 @init { 9039(
9040 int stackSize = keepStackSize(); 9040 { before(grammarAccess.getGenerationTaskAccess().getSolverAssignment_3_7_2()); }
9041 } 9041 (rule__GenerationTask__SolverAssignment_3_7_2)
9042: 9042 { after(grammarAccess.getGenerationTaskAccess().getSolverAssignment_3_7_2()); }
9043 ( 9043)
9044 { before(grammarAccess.getMetamodelDeclarationAccess().getSpecificationMetamodelSpecificationParserRuleCall_2_0()); } 9044;
9045 ruleMetamodelSpecification 9045finally {
9046 { after(grammarAccess.getMetamodelDeclarationAccess().getSpecificationMetamodelSpecificationParserRuleCall_2_0()); } 9046 restoreStackSize(stackSize);
9047 ) 9047}
9048; 9048
9049finally { 9049
9050 restoreStackSize(stackSize); 9050rule__GenerationTask__Group_3_8__0
9051} 9051 @init {
9052 9052 int stackSize = keepStackSize();
9053rule__MetamodelReference__ReferredAssignment 9053 }
9054 @init { 9054:
9055 int stackSize = keepStackSize(); 9055 rule__GenerationTask__Group_3_8__0__Impl
9056 } 9056 rule__GenerationTask__Group_3_8__1
9057: 9057;
9058 ( 9058finally {
9059 { before(grammarAccess.getMetamodelReferenceAccess().getReferredMetamodelDeclarationCrossReference_0()); } 9059 restoreStackSize(stackSize);
9060 ( 9060}
9061 { before(grammarAccess.getMetamodelReferenceAccess().getReferredMetamodelDeclarationIDTerminalRuleCall_0_1()); } 9061
9062 RULE_ID 9062rule__GenerationTask__Group_3_8__0__Impl
9063 { after(grammarAccess.getMetamodelReferenceAccess().getReferredMetamodelDeclarationIDTerminalRuleCall_0_1()); } 9063 @init {
9064 ) 9064 int stackSize = keepStackSize();
9065 { after(grammarAccess.getMetamodelReferenceAccess().getReferredMetamodelDeclarationCrossReference_0()); } 9065 }
9066 ) 9066:
9067; 9067(
9068finally { 9068 { before(grammarAccess.getGenerationTaskAccess().getConfigKeyword_3_8_0()); }
9069 restoreStackSize(stackSize); 9069 'config'
9070} 9070 { after(grammarAccess.getGenerationTaskAccess().getConfigKeyword_3_8_0()); }
9071 9071)
9072rule__PartialModelSpecification__EntryAssignment_1 9072;
9073 @init { 9073finally {
9074 int stackSize = keepStackSize(); 9074 restoreStackSize(stackSize);
9075 } 9075}
9076: 9076
9077 ( 9077rule__GenerationTask__Group_3_8__1
9078 { before(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_1_0()); } 9078 @init {
9079 rulePartialModelEntry 9079 int stackSize = keepStackSize();
9080 { after(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_1_0()); } 9080 }
9081 ) 9081:
9082; 9082 rule__GenerationTask__Group_3_8__1__Impl
9083finally { 9083 rule__GenerationTask__Group_3_8__2
9084 restoreStackSize(stackSize); 9084;
9085} 9085finally {
9086 9086 restoreStackSize(stackSize);
9087rule__PartialModelSpecification__EntryAssignment_2_1 9087}
9088 @init { 9088
9089 int stackSize = keepStackSize(); 9089rule__GenerationTask__Group_3_8__1__Impl
9090 } 9090 @init {
9091: 9091 int stackSize = keepStackSize();
9092 ( 9092 }
9093 { before(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_2_1_0()); } 9093:
9094 rulePartialModelEntry 9094(
9095 { after(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_2_1_0()); } 9095 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_8_1()); }
9096 ) 9096 '='
9097; 9097 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_8_1()); }
9098finally { 9098)
9099 restoreStackSize(stackSize); 9099;
9100} 9100finally {
9101 9101 restoreStackSize(stackSize);
9102rule__ModelEntry__PathAssignment 9102}
9103 @init { 9103
9104 int stackSize = keepStackSize(); 9104rule__GenerationTask__Group_3_8__2
9105 } 9105 @init {
9106: 9106 int stackSize = keepStackSize();
9107 ( 9107 }
9108 { before(grammarAccess.getModelEntryAccess().getPathFileParserRuleCall_0()); } 9108:
9109 ruleFile 9109 rule__GenerationTask__Group_3_8__2__Impl
9110 { after(grammarAccess.getModelEntryAccess().getPathFileParserRuleCall_0()); } 9110;
9111 ) 9111finally {
9112; 9112 restoreStackSize(stackSize);
9113finally { 9113}
9114 restoreStackSize(stackSize); 9114
9115} 9115rule__GenerationTask__Group_3_8__2__Impl
9116 9116 @init {
9117rule__FolderEntry__PathAssignment_1 9117 int stackSize = keepStackSize();
9118 @init { 9118 }
9119 int stackSize = keepStackSize(); 9119:
9120 } 9120(
9121: 9121 { before(grammarAccess.getGenerationTaskAccess().getConfigAssignment_3_8_2()); }
9122 ( 9122 (rule__GenerationTask__ConfigAssignment_3_8_2)
9123 { before(grammarAccess.getFolderEntryAccess().getPathFileParserRuleCall_1_0()); } 9123 { after(grammarAccess.getGenerationTaskAccess().getConfigAssignment_3_8_2()); }
9124 ruleFile 9124)
9125 { after(grammarAccess.getFolderEntryAccess().getPathFileParserRuleCall_1_0()); } 9125;
9126 ) 9126finally {
9127; 9127 restoreStackSize(stackSize);
9128finally { 9128}
9129 restoreStackSize(stackSize); 9129
9130} 9130
9131 9131rule__GenerationTask__Group_3_9__0
9132rule__FolderEntry__ExclusionAssignment_2_2 9132 @init {
9133 @init { 9133 int stackSize = keepStackSize();
9134 int stackSize = keepStackSize(); 9134 }
9135 } 9135:
9136: 9136 rule__GenerationTask__Group_3_9__0__Impl
9137 ( 9137 rule__GenerationTask__Group_3_9__1
9138 { before(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_2_0()); } 9138;
9139 ruleModelEntry 9139finally {
9140 { after(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_2_0()); } 9140 restoreStackSize(stackSize);
9141 ) 9141}
9142; 9142
9143finally { 9143rule__GenerationTask__Group_3_9__0__Impl
9144 restoreStackSize(stackSize); 9144 @init {
9145} 9145 int stackSize = keepStackSize();
9146 9146 }
9147rule__FolderEntry__ExclusionAssignment_2_3_1 9147:
9148 @init { 9148(
9149 int stackSize = keepStackSize(); 9149 { before(grammarAccess.getGenerationTaskAccess().getDebugKeyword_3_9_0()); }
9150 } 9150 'debug'
9151: 9151 { after(grammarAccess.getGenerationTaskAccess().getDebugKeyword_3_9_0()); }
9152 ( 9152)
9153 { before(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_3_1_0()); } 9153;
9154 ruleModelEntry 9154finally {
9155 { after(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_3_1_0()); } 9155 restoreStackSize(stackSize);
9156 ) 9156}
9157; 9157
9158finally { 9158rule__GenerationTask__Group_3_9__1
9159 restoreStackSize(stackSize); 9159 @init {
9160} 9160 int stackSize = keepStackSize();
9161 9161 }
9162rule__PartialModelDeclaration__NameAssignment_1 9162:
9163 @init { 9163 rule__GenerationTask__Group_3_9__1__Impl
9164 int stackSize = keepStackSize(); 9164 rule__GenerationTask__Group_3_9__2
9165 } 9165;
9166: 9166finally {
9167 ( 9167 restoreStackSize(stackSize);
9168 { before(grammarAccess.getPartialModelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 9168}
9169 RULE_ID 9169
9170 { after(grammarAccess.getPartialModelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 9170rule__GenerationTask__Group_3_9__1__Impl
9171 ) 9171 @init {
9172; 9172 int stackSize = keepStackSize();
9173finally { 9173 }
9174 restoreStackSize(stackSize); 9174:
9175} 9175(
9176 9176 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_9_1()); }
9177rule__PartialModelDeclaration__SpecificationAssignment_2 9177 '='
9178 @init { 9178 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_9_1()); }
9179 int stackSize = keepStackSize(); 9179)
9180 } 9180;
9181: 9181finally {
9182 ( 9182 restoreStackSize(stackSize);
9183 { before(grammarAccess.getPartialModelDeclarationAccess().getSpecificationPartialModelSpecificationParserRuleCall_2_0()); } 9183}
9184 rulePartialModelSpecification 9184
9185 { after(grammarAccess.getPartialModelDeclarationAccess().getSpecificationPartialModelSpecificationParserRuleCall_2_0()); } 9185rule__GenerationTask__Group_3_9__2
9186 ) 9186 @init {
9187; 9187 int stackSize = keepStackSize();
9188finally { 9188 }
9189 restoreStackSize(stackSize); 9189:
9190} 9190 rule__GenerationTask__Group_3_9__2__Impl
9191 9191;
9192rule__PartialModelReference__ReferredAssignment 9192finally {
9193 @init { 9193 restoreStackSize(stackSize);
9194 int stackSize = keepStackSize(); 9194}
9195 } 9195
9196: 9196rule__GenerationTask__Group_3_9__2__Impl
9197 ( 9197 @init {
9198 { before(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationCrossReference_0()); } 9198 int stackSize = keepStackSize();
9199 ( 9199 }
9200 { before(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationIDTerminalRuleCall_0_1()); } 9200:
9201 RULE_ID 9201(
9202 { after(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationIDTerminalRuleCall_0_1()); } 9202 { before(grammarAccess.getGenerationTaskAccess().getDebugFolderAssignment_3_9_2()); }
9203 ) 9203 (rule__GenerationTask__DebugFolderAssignment_3_9_2)
9204 { after(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationCrossReference_0()); } 9204 { after(grammarAccess.getGenerationTaskAccess().getDebugFolderAssignment_3_9_2()); }
9205 ) 9205)
9206; 9206;
9207finally { 9207finally {
9208 restoreStackSize(stackSize); 9208 restoreStackSize(stackSize);
9209} 9209}
9210 9210
9211rule__PatternSpecification__EntriesAssignment_1 9211
9212 @init { 9212rule__GenerationTask__Group_3_10__0
9213 int stackSize = keepStackSize(); 9213 @init {
9214 } 9214 int stackSize = keepStackSize();
9215: 9215 }
9216 ( 9216:
9217 { before(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_1_0()); } 9217 rule__GenerationTask__Group_3_10__0__Impl
9218 rulePatternEntry 9218 rule__GenerationTask__Group_3_10__1
9219 { after(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_1_0()); } 9219;
9220 ) 9220finally {
9221; 9221 restoreStackSize(stackSize);
9222finally { 9222}
9223 restoreStackSize(stackSize); 9223
9224} 9224rule__GenerationTask__Group_3_10__0__Impl
9225 9225 @init {
9226rule__PatternSpecification__EntriesAssignment_2_1 9226 int stackSize = keepStackSize();
9227 @init { 9227 }
9228 int stackSize = keepStackSize(); 9228:
9229 } 9229(
9230: 9230 { before(grammarAccess.getGenerationTaskAccess().getLogKeyword_3_10_0()); }
9231 ( 9231 'log'
9232 { before(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_2_1_0()); } 9232 { after(grammarAccess.getGenerationTaskAccess().getLogKeyword_3_10_0()); }
9233 rulePatternEntry 9233)
9234 { after(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_2_1_0()); } 9234;
9235 ) 9235finally {
9236; 9236 restoreStackSize(stackSize);
9237finally { 9237}
9238 restoreStackSize(stackSize); 9238
9239} 9239rule__GenerationTask__Group_3_10__1
9240 9240 @init {
9241rule__AllPatternEntry__PackageAssignment_1 9241 int stackSize = keepStackSize();
9242 @init { 9242 }
9243 int stackSize = keepStackSize(); 9243:
9244 } 9244 rule__GenerationTask__Group_3_10__1__Impl
9245: 9245 rule__GenerationTask__Group_3_10__2
9246 ( 9246;
9247 { before(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelCrossReference_1_0()); } 9247finally {
9248 ( 9248 restoreStackSize(stackSize);
9249 { before(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelQualifiedNameParserRuleCall_1_0_1()); } 9249}
9250 ruleQualifiedName 9250
9251 { after(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelQualifiedNameParserRuleCall_1_0_1()); } 9251rule__GenerationTask__Group_3_10__1__Impl
9252 ) 9252 @init {
9253 { after(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelCrossReference_1_0()); } 9253 int stackSize = keepStackSize();
9254 ) 9254 }
9255; 9255:
9256finally { 9256(
9257 restoreStackSize(stackSize); 9257 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_10_1()); }
9258} 9258 '='
9259 9259 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_10_1()); }
9260rule__AllPatternEntry__ExclusuionAssignment_2_2 9260)
9261 @init { 9261;
9262 int stackSize = keepStackSize(); 9262finally {
9263 } 9263 restoreStackSize(stackSize);
9264: 9264}
9265 ( 9265
9266 { before(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_2_0()); } 9266rule__GenerationTask__Group_3_10__2
9267 rulePatternElement 9267 @init {
9268 { after(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_2_0()); } 9268 int stackSize = keepStackSize();
9269 ) 9269 }
9270; 9270:
9271finally { 9271 rule__GenerationTask__Group_3_10__2__Impl
9272 restoreStackSize(stackSize); 9272;
9273} 9273finally {
9274 9274 restoreStackSize(stackSize);
9275rule__AllPatternEntry__ExclusuionAssignment_2_3_1 9275}
9276 @init { 9276
9277 int stackSize = keepStackSize(); 9277rule__GenerationTask__Group_3_10__2__Impl
9278 } 9278 @init {
9279: 9279 int stackSize = keepStackSize();
9280 ( 9280 }
9281 { before(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_3_1_0()); } 9281:
9282 rulePatternElement 9282(
9283 { after(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_3_1_0()); } 9283 { before(grammarAccess.getGenerationTaskAccess().getTargetLogFileAssignment_3_10_2()); }
9284 ) 9284 (rule__GenerationTask__TargetLogFileAssignment_3_10_2)
9285; 9285 { after(grammarAccess.getGenerationTaskAccess().getTargetLogFileAssignment_3_10_2()); }
9286finally { 9286)
9287 restoreStackSize(stackSize); 9287;
9288} 9288finally {
9289 9289 restoreStackSize(stackSize);
9290rule__PatternElement__PackageAssignment_0_0 9290}
9291 @init { 9291
9292 int stackSize = keepStackSize(); 9292
9293 } 9293rule__GenerationTask__Group_3_11__0
9294: 9294 @init {
9295 ( 9295 int stackSize = keepStackSize();
9296 { before(grammarAccess.getPatternElementAccess().getPackagePatternModelCrossReference_0_0_0()); } 9296 }
9297 ( 9297:
9298 { before(grammarAccess.getPatternElementAccess().getPackagePatternModelQualifiedNameParserRuleCall_0_0_0_1()); } 9298 rule__GenerationTask__Group_3_11__0__Impl
9299 ruleQualifiedName 9299 rule__GenerationTask__Group_3_11__1
9300 { after(grammarAccess.getPatternElementAccess().getPackagePatternModelQualifiedNameParserRuleCall_0_0_0_1()); } 9300;
9301 ) 9301finally {
9302 { after(grammarAccess.getPatternElementAccess().getPackagePatternModelCrossReference_0_0_0()); } 9302 restoreStackSize(stackSize);
9303 ) 9303}
9304; 9304
9305finally { 9305rule__GenerationTask__Group_3_11__0__Impl
9306 restoreStackSize(stackSize); 9306 @init {
9307} 9307 int stackSize = keepStackSize();
9308 9308 }
9309rule__PatternElement__PatternAssignment_1 9309:
9310 @init { 9310(
9311 int stackSize = keepStackSize(); 9311 { before(grammarAccess.getGenerationTaskAccess().getStatisticsKeyword_3_11_0()); }
9312 } 9312 'statistics'
9313: 9313 { after(grammarAccess.getGenerationTaskAccess().getStatisticsKeyword_3_11_0()); }
9314 ( 9314)
9315 { before(grammarAccess.getPatternElementAccess().getPatternPatternCrossReference_1_0()); } 9315;
9316 ( 9316finally {
9317 { before(grammarAccess.getPatternElementAccess().getPatternPatternIDTerminalRuleCall_1_0_1()); } 9317 restoreStackSize(stackSize);
9318 RULE_ID 9318}
9319 { after(grammarAccess.getPatternElementAccess().getPatternPatternIDTerminalRuleCall_1_0_1()); } 9319
9320 ) 9320rule__GenerationTask__Group_3_11__1
9321 { after(grammarAccess.getPatternElementAccess().getPatternPatternCrossReference_1_0()); } 9321 @init {
9322 ) 9322 int stackSize = keepStackSize();
9323; 9323 }
9324finally { 9324:
9325 restoreStackSize(stackSize); 9325 rule__GenerationTask__Group_3_11__1__Impl
9326} 9326 rule__GenerationTask__Group_3_11__2
9327 9327;
9328rule__GraphPatternDeclaration__NameAssignment_1 9328finally {
9329 @init { 9329 restoreStackSize(stackSize);
9330 int stackSize = keepStackSize(); 9330}
9331 } 9331
9332: 9332rule__GenerationTask__Group_3_11__1__Impl
9333 ( 9333 @init {
9334 { before(grammarAccess.getGraphPatternDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 9334 int stackSize = keepStackSize();
9335 RULE_ID 9335 }
9336 { after(grammarAccess.getGraphPatternDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 9336:
9337 ) 9337(
9338; 9338 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_11_1()); }
9339finally { 9339 '='
9340 restoreStackSize(stackSize); 9340 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_11_1()); }
9341} 9341)
9342 9342;
9343rule__GraphPatternDeclaration__SpecificationAssignment_2 9343finally {
9344 @init { 9344 restoreStackSize(stackSize);
9345 int stackSize = keepStackSize(); 9345}
9346 } 9346
9347: 9347rule__GenerationTask__Group_3_11__2
9348 ( 9348 @init {
9349 { before(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationPatternSpecificationParserRuleCall_2_0()); } 9349 int stackSize = keepStackSize();
9350 rulePatternSpecification 9350 }
9351 { after(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationPatternSpecificationParserRuleCall_2_0()); } 9351:
9352 ) 9352 rule__GenerationTask__Group_3_11__2__Impl
9353; 9353;
9354finally { 9354finally {
9355 restoreStackSize(stackSize); 9355 restoreStackSize(stackSize);
9356} 9356}
9357 9357
9358rule__GraphPatternReference__ReferredAssignment 9358rule__GenerationTask__Group_3_11__2__Impl
9359 @init { 9359 @init {
9360 int stackSize = keepStackSize(); 9360 int stackSize = keepStackSize();
9361 } 9361 }
9362: 9362:
9363 ( 9363(
9364 { before(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationCrossReference_0()); } 9364 { before(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileAssignment_3_11_2()); }
9365 ( 9365 (rule__GenerationTask__TargetStatisticsFileAssignment_3_11_2)
9366 { before(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationIDTerminalRuleCall_0_1()); } 9366 { after(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileAssignment_3_11_2()); }
9367 RULE_ID 9367)
9368 { after(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationIDTerminalRuleCall_0_1()); } 9368;
9369 ) 9369finally {
9370 { after(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationCrossReference_0()); } 9370 restoreStackSize(stackSize);
9371 ) 9371}
9372; 9372
9373finally { 9373
9374 restoreStackSize(stackSize); 9374rule__GenerationTask__Group_3_12__0
9375} 9375 @init {
9376 9376 int stackSize = keepStackSize();
9377rule__ConfigSpecification__EntriesAssignment_2_0 9377 }
9378 @init { 9378:
9379 int stackSize = keepStackSize(); 9379 rule__GenerationTask__Group_3_12__0__Impl
9380 } 9380 rule__GenerationTask__Group_3_12__1
9381: 9381;
9382 ( 9382finally {
9383 { before(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_0_0()); } 9383 restoreStackSize(stackSize);
9384 ruleConfigEntry 9384}
9385 { after(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_0_0()); } 9385
9386 ) 9386rule__GenerationTask__Group_3_12__0__Impl
9387; 9387 @init {
9388finally { 9388 int stackSize = keepStackSize();
9389 restoreStackSize(stackSize); 9389 }
9390} 9390:
9391 9391(
9392rule__ConfigSpecification__EntriesAssignment_2_1_1 9392 { before(grammarAccess.getGenerationTaskAccess().getOutputKeyword_3_12_0()); }
9393 @init { 9393 'output'
9394 int stackSize = keepStackSize(); 9394 { after(grammarAccess.getGenerationTaskAccess().getOutputKeyword_3_12_0()); }
9395 } 9395)
9396: 9396;
9397 ( 9397finally {
9398 { before(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_1_1_0()); } 9398 restoreStackSize(stackSize);
9399 ruleConfigEntry 9399}
9400 { after(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_1_1_0()); } 9400
9401 ) 9401rule__GenerationTask__Group_3_12__1
9402; 9402 @init {
9403finally { 9403 int stackSize = keepStackSize();
9404 restoreStackSize(stackSize); 9404 }
9405} 9405:
9406 9406 rule__GenerationTask__Group_3_12__1__Impl
9407rule__ConfigDeclaration__NameAssignment_1 9407 rule__GenerationTask__Group_3_12__2
9408 @init { 9408;
9409 int stackSize = keepStackSize(); 9409finally {
9410 } 9410 restoreStackSize(stackSize);
9411: 9411}
9412 ( 9412
9413 { before(grammarAccess.getConfigDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 9413rule__GenerationTask__Group_3_12__1__Impl
9414 RULE_ID 9414 @init {
9415 { after(grammarAccess.getConfigDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 9415 int stackSize = keepStackSize();
9416 ) 9416 }
9417; 9417:
9418finally { 9418(
9419 restoreStackSize(stackSize); 9419 { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_12_1()); }
9420} 9420 '='
9421 9421 { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_12_1()); }
9422rule__ConfigDeclaration__SpecificationAssignment_2 9422)
9423 @init { 9423;
9424 int stackSize = keepStackSize(); 9424finally {
9425 } 9425 restoreStackSize(stackSize);
9426: 9426}
9427 ( 9427
9428 { before(grammarAccess.getConfigDeclarationAccess().getSpecificationConfigSpecificationParserRuleCall_2_0()); } 9428rule__GenerationTask__Group_3_12__2
9429 ruleConfigSpecification 9429 @init {
9430 { after(grammarAccess.getConfigDeclarationAccess().getSpecificationConfigSpecificationParserRuleCall_2_0()); } 9430 int stackSize = keepStackSize();
9431 ) 9431 }
9432; 9432:
9433finally { 9433 rule__GenerationTask__Group_3_12__2__Impl
9434 restoreStackSize(stackSize); 9434;
9435} 9435finally {
9436 9436 restoreStackSize(stackSize);
9437rule__DocumentationEntry__LevelAssignment_2 9437}
9438 @init { 9438
9439 int stackSize = keepStackSize(); 9439rule__GenerationTask__Group_3_12__2__Impl
9440 } 9440 @init {
9441: 9441 int stackSize = keepStackSize();
9442 ( 9442 }
9443 { before(grammarAccess.getDocumentationEntryAccess().getLevelDocumentLevelSpecificationEnumRuleCall_2_0()); } 9443:
9444 ruleDocumentLevelSpecification 9444(
9445 { after(grammarAccess.getDocumentationEntryAccess().getLevelDocumentLevelSpecificationEnumRuleCall_2_0()); } 9445 { before(grammarAccess.getGenerationTaskAccess().getTagetFolderAssignment_3_12_2()); }
9446 ) 9446 (rule__GenerationTask__TagetFolderAssignment_3_12_2)
9447; 9447 { after(grammarAccess.getGenerationTaskAccess().getTagetFolderAssignment_3_12_2()); }
9448finally { 9448)
9449 restoreStackSize(stackSize); 9449;
9450} 9450finally {
9451 9451 restoreStackSize(stackSize);
9452rule__RuntimeEntry__MillisecLimitAssignment_2 9452}
9453 @init { 9453
9454 int stackSize = keepStackSize(); 9454
9455 } 9455rule__GenerationTask__UnorderedGroup_3
9456: 9456 @init {
9457 ( 9457 int stackSize = keepStackSize();
9458 { before(grammarAccess.getRuntimeEntryAccess().getMillisecLimitINTTerminalRuleCall_2_0()); } 9458 getUnorderedGroupHelper().enter(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3());
9459 RULE_INT 9459 }
9460 { after(grammarAccess.getRuntimeEntryAccess().getMillisecLimitINTTerminalRuleCall_2_0()); } 9460:
9461 ) 9461 rule__GenerationTask__UnorderedGroup_3__0
9462; 9462 ?
9463finally { 9463;
9464 restoreStackSize(stackSize); 9464finally {
9465} 9465 getUnorderedGroupHelper().leave(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3());
9466 9466 restoreStackSize(stackSize);
9467rule__MemoryEntry__MegabyteLimitAssignment_2 9467}
9468 @init { 9468
9469 int stackSize = keepStackSize(); 9469rule__GenerationTask__UnorderedGroup_3__Impl
9470 } 9470 @init {
9471: 9471 int stackSize = keepStackSize();
9472 ( 9472 boolean selected = false;
9473 { before(grammarAccess.getMemoryEntryAccess().getMegabyteLimitINTTerminalRuleCall_2_0()); } 9473 }
9474 RULE_INT 9474:
9475 { after(grammarAccess.getMemoryEntryAccess().getMegabyteLimitINTTerminalRuleCall_2_0()); } 9475 (
9476 ) 9476 (
9477; 9477 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 0)}?=>(
9478finally { 9478 {
9479 restoreStackSize(stackSize); 9479 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 0);
9480} 9480 }
9481 9481 {
9482rule__CustomEntry__KeyAssignment_0 9482 selected = true;
9483 @init { 9483 }
9484 int stackSize = keepStackSize(); 9484 (
9485 } 9485 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_0()); }
9486: 9486 (rule__GenerationTask__Group_3_0__0)
9487 ( 9487 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_0()); }
9488 { before(grammarAccess.getCustomEntryAccess().getKeySTRINGTerminalRuleCall_0_0()); } 9488 )
9489 RULE_STRING 9489 )
9490 { after(grammarAccess.getCustomEntryAccess().getKeySTRINGTerminalRuleCall_0_0()); } 9490 )|
9491 ) 9491 (
9492; 9492 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 1)}?=>(
9493finally { 9493 {
9494 restoreStackSize(stackSize); 9494 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 1);
9495} 9495 }
9496 9496 {
9497rule__CustomEntry__ValueAssignment_2 9497 selected = true;
9498 @init { 9498 }
9499 int stackSize = keepStackSize(); 9499 (
9500 } 9500 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_1()); }
9501: 9501 (rule__GenerationTask__Group_3_1__0)
9502 ( 9502 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_1()); }
9503 { before(grammarAccess.getCustomEntryAccess().getValueSTRINGTerminalRuleCall_2_0()); } 9503 )
9504 RULE_STRING 9504 )
9505 { after(grammarAccess.getCustomEntryAccess().getValueSTRINGTerminalRuleCall_2_0()); } 9505 )|
9506 ) 9506 (
9507; 9507 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 2)}?=>(
9508finally { 9508 {
9509 restoreStackSize(stackSize); 9509 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 2);
9510} 9510 }
9511 9511 {
9512rule__ConfigReference__ConfigAssignment 9512 selected = true;
9513 @init { 9513 }
9514 int stackSize = keepStackSize(); 9514 (
9515 } 9515 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_2()); }
9516: 9516 (rule__GenerationTask__Group_3_2__0)
9517 ( 9517 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_2()); }
9518 { before(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationCrossReference_0()); } 9518 )
9519 ( 9519 )
9520 { before(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationIDTerminalRuleCall_0_1()); } 9520 )|
9521 RULE_ID 9521 (
9522 { after(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationIDTerminalRuleCall_0_1()); } 9522 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 3)}?=>(
9523 ) 9523 {
9524 { after(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationCrossReference_0()); } 9524 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 3);
9525 ) 9525 }
9526; 9526 {
9527finally { 9527 selected = true;
9528 restoreStackSize(stackSize); 9528 }
9529} 9529 (
9530 9530 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_3()); }
9531rule__ScopeSpecification__ScopesAssignment_2_0 9531 (rule__GenerationTask__Group_3_3__0)
9532 @init { 9532 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_3()); }
9533 int stackSize = keepStackSize(); 9533 )
9534 } 9534 )
9535: 9535 )|
9536 ( 9536 (
9537 { before(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_0_0()); } 9537 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 4)}?=>(
9538 ruleTypeScope 9538 {
9539 { after(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_0_0()); } 9539 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 4);
9540 ) 9540 }
9541; 9541 {
9542finally { 9542 selected = true;
9543 restoreStackSize(stackSize); 9543 }
9544} 9544 (
9545 9545 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_4()); }
9546rule__ScopeSpecification__ScopesAssignment_2_1_1 9546 (rule__GenerationTask__Group_3_4__0)
9547 @init { 9547 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_4()); }
9548 int stackSize = keepStackSize(); 9548 )
9549 } 9549 )
9550: 9550 )|
9551 ( 9551 (
9552 { before(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_1_1_0()); } 9552 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 5)}?=>(
9553 ruleTypeScope 9553 {
9554 { after(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_1_1_0()); } 9554 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 5);
9555 ) 9555 }
9556; 9556 {
9557finally { 9557 selected = true;
9558 restoreStackSize(stackSize); 9558 }
9559} 9559 (
9560 9560 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_5()); }
9561rule__ClassTypeScope__TypeAssignment_1 9561 (rule__GenerationTask__Group_3_5__0)
9562 @init { 9562 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_5()); }
9563 int stackSize = keepStackSize(); 9563 )
9564 } 9564 )
9565: 9565 )|
9566 ( 9566 (
9567 { before(grammarAccess.getClassTypeScopeAccess().getTypeClassReferenceParserRuleCall_1_0()); } 9567 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 6)}?=>(
9568 ruleClassReference 9568 {
9569 { after(grammarAccess.getClassTypeScopeAccess().getTypeClassReferenceParserRuleCall_1_0()); } 9569 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 6);
9570 ) 9570 }
9571; 9571 {
9572finally { 9572 selected = true;
9573 restoreStackSize(stackSize); 9573 }
9574} 9574 (
9575 9575 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_6()); }
9576rule__ClassTypeScope__SetsNewAssignment_2_0 9576 (rule__GenerationTask__Group_3_6__0)
9577 @init { 9577 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_6()); }
9578 int stackSize = keepStackSize(); 9578 )
9579 } 9579 )
9580: 9580 )|
9581 ( 9581 (
9582 { before(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9582 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 7)}?=>(
9583 ( 9583 {
9584 { before(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9584 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 7);
9585 '+=' 9585 }
9586 { after(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9586 {
9587 ) 9587 selected = true;
9588 { after(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9588 }
9589 ) 9589 (
9590; 9590 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_7()); }
9591finally { 9591 (rule__GenerationTask__Group_3_7__0)
9592 restoreStackSize(stackSize); 9592 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_7()); }
9593} 9593 )
9594 9594 )
9595rule__ClassTypeScope__SetsSumAssignment_2_1 9595 )|
9596 @init { 9596 (
9597 int stackSize = keepStackSize(); 9597 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 8)}?=>(
9598 } 9598 {
9599: 9599 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 8);
9600 ( 9600 }
9601 { before(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9601 {
9602 ( 9602 selected = true;
9603 { before(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9603 }
9604 '=' 9604 (
9605 { after(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9605 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_8()); }
9606 ) 9606 (rule__GenerationTask__Group_3_8__0)
9607 { after(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9607 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_8()); }
9608 ) 9608 )
9609; 9609 )
9610finally { 9610 )|
9611 restoreStackSize(stackSize); 9611 (
9612} 9612 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 9)}?=>(
9613 9613 {
9614rule__ClassTypeScope__NumberAssignment_3_0 9614 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 9);
9615 @init { 9615 }
9616 int stackSize = keepStackSize(); 9616 {
9617 } 9617 selected = true;
9618: 9618 }
9619 ( 9619 (
9620 { before(grammarAccess.getClassTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } 9620 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_9()); }
9621 ruleExactNumber 9621 (rule__GenerationTask__Group_3_9__0)
9622 { after(grammarAccess.getClassTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } 9622 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_9()); }
9623 ) 9623 )
9624; 9624 )
9625finally { 9625 )|
9626 restoreStackSize(stackSize); 9626 (
9627} 9627 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 10)}?=>(
9628 9628 {
9629rule__ClassTypeScope__NumberAssignment_3_1 9629 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 10);
9630 @init { 9630 }
9631 int stackSize = keepStackSize(); 9631 {
9632 } 9632 selected = true;
9633: 9633 }
9634 ( 9634 (
9635 { before(grammarAccess.getClassTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } 9635 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_10()); }
9636 ruleIntervallNumber 9636 (rule__GenerationTask__Group_3_10__0)
9637 { after(grammarAccess.getClassTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } 9637 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_10()); }
9638 ) 9638 )
9639; 9639 )
9640finally { 9640 )|
9641 restoreStackSize(stackSize); 9641 (
9642} 9642 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 11)}?=>(
9643 9643 {
9644rule__ObjectTypeScope__TypeAssignment_1 9644 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 11);
9645 @init { 9645 }
9646 int stackSize = keepStackSize(); 9646 {
9647 } 9647 selected = true;
9648: 9648 }
9649 ( 9649 (
9650 { before(grammarAccess.getObjectTypeScopeAccess().getTypeObjectReferenceParserRuleCall_1_0()); } 9650 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_11()); }
9651 ruleObjectReference 9651 (rule__GenerationTask__Group_3_11__0)
9652 { after(grammarAccess.getObjectTypeScopeAccess().getTypeObjectReferenceParserRuleCall_1_0()); } 9652 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_11()); }
9653 ) 9653 )
9654; 9654 )
9655finally { 9655 )|
9656 restoreStackSize(stackSize); 9656 (
9657} 9657 {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 12)}?=>(
9658 9658 {
9659rule__ObjectTypeScope__SetsNewAssignment_2_0 9659 getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 12);
9660 @init { 9660 }
9661 int stackSize = keepStackSize(); 9661 {
9662 } 9662 selected = true;
9663: 9663 }
9664 ( 9664 (
9665 { before(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9665 { before(grammarAccess.getGenerationTaskAccess().getGroup_3_12()); }
9666 ( 9666 (rule__GenerationTask__Group_3_12__0)
9667 { before(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9667 { after(grammarAccess.getGenerationTaskAccess().getGroup_3_12()); }
9668 '+=' 9668 )
9669 { after(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9669 )
9670 ) 9670 )
9671 { after(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9671 )
9672 ) 9672;
9673; 9673finally {
9674finally { 9674 if (selected)
9675 restoreStackSize(stackSize); 9675 getUnorderedGroupHelper().returnFromSelection(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3());
9676} 9676 restoreStackSize(stackSize);
9677 9677}
9678rule__ObjectTypeScope__SetsSumAssignment_2_1 9678
9679 @init { 9679rule__GenerationTask__UnorderedGroup_3__0
9680 int stackSize = keepStackSize(); 9680 @init {
9681 } 9681 int stackSize = keepStackSize();
9682: 9682 }
9683 ( 9683:
9684 { before(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9684 rule__GenerationTask__UnorderedGroup_3__Impl
9685 ( 9685 rule__GenerationTask__UnorderedGroup_3__1?
9686 { before(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9686;
9687 '=' 9687finally {
9688 { after(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9688 restoreStackSize(stackSize);
9689 ) 9689}
9690 { after(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9690
9691 ) 9691rule__GenerationTask__UnorderedGroup_3__1
9692; 9692 @init {
9693finally { 9693 int stackSize = keepStackSize();
9694 restoreStackSize(stackSize); 9694 }
9695} 9695:
9696 9696 rule__GenerationTask__UnorderedGroup_3__Impl
9697rule__ObjectTypeScope__NumberAssignment_3_0 9697 rule__GenerationTask__UnorderedGroup_3__2?
9698 @init { 9698;
9699 int stackSize = keepStackSize(); 9699finally {
9700 } 9700 restoreStackSize(stackSize);
9701: 9701}
9702 ( 9702
9703 { before(grammarAccess.getObjectTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } 9703rule__GenerationTask__UnorderedGroup_3__2
9704 ruleExactNumber 9704 @init {
9705 { after(grammarAccess.getObjectTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } 9705 int stackSize = keepStackSize();
9706 ) 9706 }
9707; 9707:
9708finally { 9708 rule__GenerationTask__UnorderedGroup_3__Impl
9709 restoreStackSize(stackSize); 9709 rule__GenerationTask__UnorderedGroup_3__3?
9710} 9710;
9711 9711finally {
9712rule__ObjectTypeScope__NumberAssignment_3_1 9712 restoreStackSize(stackSize);
9713 @init { 9713}
9714 int stackSize = keepStackSize(); 9714
9715 } 9715rule__GenerationTask__UnorderedGroup_3__3
9716: 9716 @init {
9717 ( 9717 int stackSize = keepStackSize();
9718 { before(grammarAccess.getObjectTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } 9718 }
9719 ruleIntervallNumber 9719:
9720 { after(grammarAccess.getObjectTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } 9720 rule__GenerationTask__UnorderedGroup_3__Impl
9721 ) 9721 rule__GenerationTask__UnorderedGroup_3__4?
9722; 9722;
9723finally { 9723finally {
9724 restoreStackSize(stackSize); 9724 restoreStackSize(stackSize);
9725} 9725}
9726 9726
9727rule__IntegerTypeScope__TypeAssignment_1 9727rule__GenerationTask__UnorderedGroup_3__4
9728 @init { 9728 @init {
9729 int stackSize = keepStackSize(); 9729 int stackSize = keepStackSize();
9730 } 9730 }
9731: 9731:
9732 ( 9732 rule__GenerationTask__UnorderedGroup_3__Impl
9733 { before(grammarAccess.getIntegerTypeScopeAccess().getTypeIntegerReferenceParserRuleCall_1_0()); } 9733 rule__GenerationTask__UnorderedGroup_3__5?
9734 ruleIntegerReference 9734;
9735 { after(grammarAccess.getIntegerTypeScopeAccess().getTypeIntegerReferenceParserRuleCall_1_0()); } 9735finally {
9736 ) 9736 restoreStackSize(stackSize);
9737; 9737}
9738finally { 9738
9739 restoreStackSize(stackSize); 9739rule__GenerationTask__UnorderedGroup_3__5
9740} 9740 @init {
9741 9741 int stackSize = keepStackSize();
9742rule__IntegerTypeScope__SetsNewAssignment_2_0 9742 }
9743 @init { 9743:
9744 int stackSize = keepStackSize(); 9744 rule__GenerationTask__UnorderedGroup_3__Impl
9745 } 9745 rule__GenerationTask__UnorderedGroup_3__6?
9746: 9746;
9747 ( 9747finally {
9748 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9748 restoreStackSize(stackSize);
9749 ( 9749}
9750 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9750
9751 '+=' 9751rule__GenerationTask__UnorderedGroup_3__6
9752 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9752 @init {
9753 ) 9753 int stackSize = keepStackSize();
9754 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9754 }
9755 ) 9755:
9756; 9756 rule__GenerationTask__UnorderedGroup_3__Impl
9757finally { 9757 rule__GenerationTask__UnorderedGroup_3__7?
9758 restoreStackSize(stackSize); 9758;
9759} 9759finally {
9760 9760 restoreStackSize(stackSize);
9761rule__IntegerTypeScope__SetsSumAssignment_2_1 9761}
9762 @init { 9762
9763 int stackSize = keepStackSize(); 9763rule__GenerationTask__UnorderedGroup_3__7
9764 } 9764 @init {
9765: 9765 int stackSize = keepStackSize();
9766 ( 9766 }
9767 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9767:
9768 ( 9768 rule__GenerationTask__UnorderedGroup_3__Impl
9769 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9769 rule__GenerationTask__UnorderedGroup_3__8?
9770 '=' 9770;
9771 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9771finally {
9772 ) 9772 restoreStackSize(stackSize);
9773 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9773}
9774 ) 9774
9775; 9775rule__GenerationTask__UnorderedGroup_3__8
9776finally { 9776 @init {
9777 restoreStackSize(stackSize); 9777 int stackSize = keepStackSize();
9778} 9778 }
9779 9779:
9780rule__IntegerTypeScope__NumberAssignment_3_0 9780 rule__GenerationTask__UnorderedGroup_3__Impl
9781 @init { 9781 rule__GenerationTask__UnorderedGroup_3__9?
9782 int stackSize = keepStackSize(); 9782;
9783 } 9783finally {
9784: 9784 restoreStackSize(stackSize);
9785 ( 9785}
9786 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } 9786
9787 ruleExactNumber 9787rule__GenerationTask__UnorderedGroup_3__9
9788 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } 9788 @init {
9789 ) 9789 int stackSize = keepStackSize();
9790; 9790 }
9791finally { 9791:
9792 restoreStackSize(stackSize); 9792 rule__GenerationTask__UnorderedGroup_3__Impl
9793} 9793 rule__GenerationTask__UnorderedGroup_3__10?
9794 9794;
9795rule__IntegerTypeScope__NumberAssignment_3_1 9795finally {
9796 @init { 9796 restoreStackSize(stackSize);
9797 int stackSize = keepStackSize(); 9797}
9798 } 9798
9799: 9799rule__GenerationTask__UnorderedGroup_3__10
9800 ( 9800 @init {
9801 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } 9801 int stackSize = keepStackSize();
9802 ruleIntervallNumber 9802 }
9803 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } 9803:
9804 ) 9804 rule__GenerationTask__UnorderedGroup_3__Impl
9805; 9805 rule__GenerationTask__UnorderedGroup_3__11?
9806finally { 9806;
9807 restoreStackSize(stackSize); 9807finally {
9808} 9808 restoreStackSize(stackSize);
9809 9809}
9810rule__IntegerTypeScope__NumberAssignment_3_2 9810
9811 @init { 9811rule__GenerationTask__UnorderedGroup_3__11
9812 int stackSize = keepStackSize(); 9812 @init {
9813 } 9813 int stackSize = keepStackSize();
9814: 9814 }
9815 ( 9815:
9816 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberIntEnumberationParserRuleCall_3_2_0()); } 9816 rule__GenerationTask__UnorderedGroup_3__Impl
9817 ruleIntEnumberation 9817 rule__GenerationTask__UnorderedGroup_3__12?
9818 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberIntEnumberationParserRuleCall_3_2_0()); } 9818;
9819 ) 9819finally {
9820; 9820 restoreStackSize(stackSize);
9821finally { 9821}
9822 restoreStackSize(stackSize); 9822
9823} 9823rule__GenerationTask__UnorderedGroup_3__12
9824 9824 @init {
9825rule__RealTypeScope__TypeAssignment_1 9825 int stackSize = keepStackSize();
9826 @init { 9826 }
9827 int stackSize = keepStackSize(); 9827:
9828 } 9828 rule__GenerationTask__UnorderedGroup_3__Impl
9829: 9829;
9830 ( 9830finally {
9831 { before(grammarAccess.getRealTypeScopeAccess().getTypeRealReferenceParserRuleCall_1_0()); } 9831 restoreStackSize(stackSize);
9832 ruleRealReference 9832}
9833 { after(grammarAccess.getRealTypeScopeAccess().getTypeRealReferenceParserRuleCall_1_0()); } 9833
9834 ) 9834
9835; 9835rule__ConfigurationScript__ImportsAssignment_0
9836finally { 9836 @init {
9837 restoreStackSize(stackSize); 9837 int stackSize = keepStackSize();
9838} 9838 }
9839 9839:
9840rule__RealTypeScope__SetsNewAssignment_2_0 9840 (
9841 @init { 9841 { before(grammarAccess.getConfigurationScriptAccess().getImportsImportParserRuleCall_0_0()); }
9842 int stackSize = keepStackSize(); 9842 ruleImport
9843 } 9843 { after(grammarAccess.getConfigurationScriptAccess().getImportsImportParserRuleCall_0_0()); }
9844: 9844 )
9845 ( 9845;
9846 { before(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9846finally {
9847 ( 9847 restoreStackSize(stackSize);
9848 { before(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9848}
9849 '+=' 9849
9850 { after(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9850rule__ConfigurationScript__CommandsAssignment_1
9851 ) 9851 @init {
9852 { after(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9852 int stackSize = keepStackSize();
9853 ) 9853 }
9854; 9854:
9855finally { 9855 (
9856 restoreStackSize(stackSize); 9856 { before(grammarAccess.getConfigurationScriptAccess().getCommandsCommandParserRuleCall_1_0()); }
9857} 9857 ruleCommand
9858 9858 { after(grammarAccess.getConfigurationScriptAccess().getCommandsCommandParserRuleCall_1_0()); }
9859rule__RealTypeScope__SetsSumAssignment_2_1 9859 )
9860 @init { 9860;
9861 int stackSize = keepStackSize(); 9861finally {
9862 } 9862 restoreStackSize(stackSize);
9863: 9863}
9864 ( 9864
9865 { before(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9865rule__EPackageImport__ImportedPackageAssignment_2
9866 ( 9866 @init {
9867 { before(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9867 int stackSize = keepStackSize();
9868 '=' 9868 }
9869 { after(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9869:
9870 ) 9870 (
9871 { after(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9871 { before(grammarAccess.getEPackageImportAccess().getImportedPackageEPackageCrossReference_2_0()); }
9872 ) 9872 (
9873; 9873 { before(grammarAccess.getEPackageImportAccess().getImportedPackageEPackageSTRINGTerminalRuleCall_2_0_1()); }
9874finally { 9874 RULE_STRING
9875 restoreStackSize(stackSize); 9875 { after(grammarAccess.getEPackageImportAccess().getImportedPackageEPackageSTRINGTerminalRuleCall_2_0_1()); }
9876} 9876 )
9877 9877 { after(grammarAccess.getEPackageImportAccess().getImportedPackageEPackageCrossReference_2_0()); }
9878rule__RealTypeScope__NumberAssignment_3_0 9878 )
9879 @init { 9879;
9880 int stackSize = keepStackSize(); 9880finally {
9881 } 9881 restoreStackSize(stackSize);
9882: 9882}
9883 ( 9883
9884 { before(grammarAccess.getRealTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } 9884rule__ViatraImport__ImportedViatraAssignment_2
9885 ruleExactNumber 9885 @init {
9886 { after(grammarAccess.getRealTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } 9886 int stackSize = keepStackSize();
9887 ) 9887 }
9888; 9888:
9889finally { 9889 (
9890 restoreStackSize(stackSize); 9890 { before(grammarAccess.getViatraImportAccess().getImportedViatraPatternModelCrossReference_2_0()); }
9891} 9891 (
9892 9892 { before(grammarAccess.getViatraImportAccess().getImportedViatraPatternModelSTRINGTerminalRuleCall_2_0_1()); }
9893rule__RealTypeScope__NumberAssignment_3_1 9893 RULE_STRING
9894 @init { 9894 { after(grammarAccess.getViatraImportAccess().getImportedViatraPatternModelSTRINGTerminalRuleCall_2_0_1()); }
9895 int stackSize = keepStackSize(); 9895 )
9896 } 9896 { after(grammarAccess.getViatraImportAccess().getImportedViatraPatternModelCrossReference_2_0()); }
9897: 9897 )
9898 ( 9898;
9899 { before(grammarAccess.getRealTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } 9899finally {
9900 ruleIntervallNumber 9900 restoreStackSize(stackSize);
9901 { after(grammarAccess.getRealTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } 9901}
9902 ) 9902
9903; 9903rule__CftImport__ImportedCftAssignment_2
9904finally { 9904 @init {
9905 restoreStackSize(stackSize); 9905 int stackSize = keepStackSize();
9906} 9906 }
9907 9907:
9908rule__RealTypeScope__NumberAssignment_3_2 9908 (
9909 @init { 9909 { before(grammarAccess.getCftImportAccess().getImportedCftCftModelCrossReference_2_0()); }
9910 int stackSize = keepStackSize(); 9910 (
9911 } 9911 { before(grammarAccess.getCftImportAccess().getImportedCftCftModelSTRINGTerminalRuleCall_2_0_1()); }
9912: 9912 RULE_STRING
9913 ( 9913 { after(grammarAccess.getCftImportAccess().getImportedCftCftModelSTRINGTerminalRuleCall_2_0_1()); }
9914 { before(grammarAccess.getRealTypeScopeAccess().getNumberRealEnumerationParserRuleCall_3_2_0()); } 9914 )
9915 ruleRealEnumeration 9915 { after(grammarAccess.getCftImportAccess().getImportedCftCftModelCrossReference_2_0()); }
9916 { after(grammarAccess.getRealTypeScopeAccess().getNumberRealEnumerationParserRuleCall_3_2_0()); } 9916 )
9917 ) 9917;
9918; 9918finally {
9919finally { 9919 restoreStackSize(stackSize);
9920 restoreStackSize(stackSize); 9920}
9921} 9921
9922 9922rule__FileSpecification__PathAssignment
9923rule__StringTypeScope__TypeAssignment_1 9923 @init {
9924 @init { 9924 int stackSize = keepStackSize();
9925 int stackSize = keepStackSize(); 9925 }
9926 } 9926:
9927: 9927 (
9928 ( 9928 { before(grammarAccess.getFileSpecificationAccess().getPathSTRINGTerminalRuleCall_0()); }
9929 { before(grammarAccess.getStringTypeScopeAccess().getTypeStringReferenceParserRuleCall_1_0()); } 9929 RULE_STRING
9930 ruleStringReference 9930 { after(grammarAccess.getFileSpecificationAccess().getPathSTRINGTerminalRuleCall_0()); }
9931 { after(grammarAccess.getStringTypeScopeAccess().getTypeStringReferenceParserRuleCall_1_0()); } 9931 )
9932 ) 9932;
9933; 9933finally {
9934finally { 9934 restoreStackSize(stackSize);
9935 restoreStackSize(stackSize); 9935}
9936} 9936
9937 9937rule__FileDeclaration__NameAssignment_1
9938rule__StringTypeScope__SetsNewAssignment_2_0 9938 @init {
9939 @init { 9939 int stackSize = keepStackSize();
9940 int stackSize = keepStackSize(); 9940 }
9941 } 9941:
9942: 9942 (
9943 ( 9943 { before(grammarAccess.getFileDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
9944 { before(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9944 RULE_ID
9945 ( 9945 { after(grammarAccess.getFileDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
9946 { before(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9946 )
9947 '+=' 9947;
9948 { after(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9948finally {
9949 ) 9949 restoreStackSize(stackSize);
9950 { after(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } 9950}
9951 ) 9951
9952; 9952rule__FileDeclaration__SpecificationAssignment_3
9953finally { 9953 @init {
9954 restoreStackSize(stackSize); 9954 int stackSize = keepStackSize();
9955} 9955 }
9956 9956:
9957rule__StringTypeScope__SetsSumAssignment_2_1 9957 (
9958 @init { 9958 { before(grammarAccess.getFileDeclarationAccess().getSpecificationFileSpecificationParserRuleCall_3_0()); }
9959 int stackSize = keepStackSize(); 9959 ruleFileSpecification
9960 } 9960 { after(grammarAccess.getFileDeclarationAccess().getSpecificationFileSpecificationParserRuleCall_3_0()); }
9961: 9961 )
9962 ( 9962;
9963 { before(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9963finally {
9964 ( 9964 restoreStackSize(stackSize);
9965 { before(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9965}
9966 '=' 9966
9967 { after(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9967rule__FileReference__ReferredAssignment
9968 ) 9968 @init {
9969 { after(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } 9969 int stackSize = keepStackSize();
9970 ) 9970 }
9971; 9971:
9972finally { 9972 (
9973 restoreStackSize(stackSize); 9973 { before(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationCrossReference_0()); }
9974} 9974 (
9975 9975 { before(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationIDTerminalRuleCall_0_1()); }
9976rule__StringTypeScope__NumberAssignment_3_0 9976 RULE_ID
9977 @init { 9977 { after(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationIDTerminalRuleCall_0_1()); }
9978 int stackSize = keepStackSize(); 9978 )
9979 } 9979 { after(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationCrossReference_0()); }
9980: 9980 )
9981 ( 9981;
9982 { before(grammarAccess.getStringTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } 9982finally {
9983 ruleExactNumber 9983 restoreStackSize(stackSize);
9984 { after(grammarAccess.getStringTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } 9984}
9985 ) 9985
9986; 9986rule__MetamodelSpecification__EntriesAssignment_1
9987finally { 9987 @init {
9988 restoreStackSize(stackSize); 9988 int stackSize = keepStackSize();
9989} 9989 }
9990 9990:
9991rule__StringTypeScope__NumberAssignment_3_1 9991 (
9992 @init { 9992 { before(grammarAccess.getMetamodelSpecificationAccess().getEntriesMetamodelEntryParserRuleCall_1_0()); }
9993 int stackSize = keepStackSize(); 9993 ruleMetamodelEntry
9994 } 9994 { after(grammarAccess.getMetamodelSpecificationAccess().getEntriesMetamodelEntryParserRuleCall_1_0()); }
9995: 9995 )
9996 ( 9996;
9997 { before(grammarAccess.getStringTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } 9997finally {
9998 ruleIntervallNumber 9998 restoreStackSize(stackSize);
9999 { after(grammarAccess.getStringTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } 9999}
10000 ) 10000
10001; 10001rule__MetamodelSpecification__EntriesAssignment_2_1
10002finally { 10002 @init {
10003 restoreStackSize(stackSize); 10003 int stackSize = keepStackSize();
10004} 10004 }
10005 10005:
10006rule__StringTypeScope__NumberAssignment_3_2 10006 (
10007 @init { 10007 { before(grammarAccess.getMetamodelSpecificationAccess().getEntriesMetamodelEntryParserRuleCall_2_1_0()); }
10008 int stackSize = keepStackSize(); 10008 ruleMetamodelEntry
10009 } 10009 { after(grammarAccess.getMetamodelSpecificationAccess().getEntriesMetamodelEntryParserRuleCall_2_1_0()); }
10010: 10010 )
10011 ( 10011;
10012 { before(grammarAccess.getStringTypeScopeAccess().getNumberStringEnumerationParserRuleCall_3_2_0()); } 10012finally {
10013 ruleStringEnumeration 10013 restoreStackSize(stackSize);
10014 { after(grammarAccess.getStringTypeScopeAccess().getNumberStringEnumerationParserRuleCall_3_2_0()); } 10014}
10015 ) 10015
10016; 10016rule__AllPackageEntry__PackageAssignment_1
10017finally { 10017 @init {
10018 restoreStackSize(stackSize); 10018 int stackSize = keepStackSize();
10019} 10019 }
10020 10020:
10021rule__ClassReference__ElementAssignment_1 10021 (
10022 @init { 10022 { before(grammarAccess.getAllPackageEntryAccess().getPackageEPackageCrossReference_1_0()); }
10023 int stackSize = keepStackSize(); 10023 (
10024 } 10024 { before(grammarAccess.getAllPackageEntryAccess().getPackageEPackageQualifiedNameParserRuleCall_1_0_1()); }
10025: 10025 ruleQualifiedName
10026 ( 10026 { after(grammarAccess.getAllPackageEntryAccess().getPackageEPackageQualifiedNameParserRuleCall_1_0_1()); }
10027 { before(grammarAccess.getClassReferenceAccess().getElementMetamodelElementParserRuleCall_1_0()); } 10027 )
10028 ruleMetamodelElement 10028 { after(grammarAccess.getAllPackageEntryAccess().getPackageEPackageCrossReference_1_0()); }
10029 { after(grammarAccess.getClassReferenceAccess().getElementMetamodelElementParserRuleCall_1_0()); } 10029 )
10030 ) 10030;
10031; 10031finally {
10032finally { 10032 restoreStackSize(stackSize);
10033 restoreStackSize(stackSize); 10033}
10034} 10034
10035 10035rule__AllPackageEntry__ExclusionAssignment_2_2
10036rule__ExactNumber__ExactNumberAssignment_0 10036 @init {
10037 @init { 10037 int stackSize = keepStackSize();
10038 int stackSize = keepStackSize(); 10038 }
10039 } 10039:
10040: 10040 (
10041 ( 10041 { before(grammarAccess.getAllPackageEntryAccess().getExclusionMetamodelElementParserRuleCall_2_2_0()); }
10042 { before(grammarAccess.getExactNumberAccess().getExactNumberINTTerminalRuleCall_0_0()); } 10042 ruleMetamodelElement
10043 RULE_INT 10043 { after(grammarAccess.getAllPackageEntryAccess().getExclusionMetamodelElementParserRuleCall_2_2_0()); }
10044 { after(grammarAccess.getExactNumberAccess().getExactNumberINTTerminalRuleCall_0_0()); } 10044 )
10045 ) 10045;
10046; 10046finally {
10047finally { 10047 restoreStackSize(stackSize);
10048 restoreStackSize(stackSize); 10048}
10049} 10049
10050 10050rule__AllPackageEntry__ExclusionAssignment_2_3_1
10051rule__ExactNumber__ExactUnlimitedAssignment_1 10051 @init {
10052 @init { 10052 int stackSize = keepStackSize();
10053 int stackSize = keepStackSize(); 10053 }
10054 } 10054:
10055: 10055 (
10056 ( 10056 { before(grammarAccess.getAllPackageEntryAccess().getExclusionMetamodelElementParserRuleCall_2_3_1_0()); }
10057 { before(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); } 10057 ruleMetamodelElement
10058 ( 10058 { after(grammarAccess.getAllPackageEntryAccess().getExclusionMetamodelElementParserRuleCall_2_3_1_0()); }
10059 { before(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); } 10059 )
10060 '*' 10060;
10061 { after(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); } 10061finally {
10062 ) 10062 restoreStackSize(stackSize);
10063 { after(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); } 10063}
10064 ) 10064
10065; 10065rule__MetamodelElement__PackageAssignment_0_0
10066finally { 10066 @init {
10067 restoreStackSize(stackSize); 10067 int stackSize = keepStackSize();
10068} 10068 }
10069 10069:
10070rule__IntervallNumber__MinAssignment_0 10070 (
10071 @init { 10071 { before(grammarAccess.getMetamodelElementAccess().getPackageEPackageCrossReference_0_0_0()); }
10072 int stackSize = keepStackSize(); 10072 (
10073 } 10073 { before(grammarAccess.getMetamodelElementAccess().getPackageEPackageQualifiedNameParserRuleCall_0_0_0_1()); }
10074: 10074 ruleQualifiedName
10075 ( 10075 { after(grammarAccess.getMetamodelElementAccess().getPackageEPackageQualifiedNameParserRuleCall_0_0_0_1()); }
10076 { before(grammarAccess.getIntervallNumberAccess().getMinINTTerminalRuleCall_0_0()); } 10076 )
10077 RULE_INT 10077 { after(grammarAccess.getMetamodelElementAccess().getPackageEPackageCrossReference_0_0_0()); }
10078 { after(grammarAccess.getIntervallNumberAccess().getMinINTTerminalRuleCall_0_0()); } 10078 )
10079 ) 10079;
10080; 10080finally {
10081finally { 10081 restoreStackSize(stackSize);
10082 restoreStackSize(stackSize); 10082}
10083} 10083
10084 10084rule__MetamodelElement__ClassifierAssignment_1
10085rule__IntervallNumber__MaxNumberAssignment_2_0 10085 @init {
10086 @init { 10086 int stackSize = keepStackSize();
10087 int stackSize = keepStackSize(); 10087 }
10088 } 10088:
10089: 10089 (
10090 ( 10090 { before(grammarAccess.getMetamodelElementAccess().getClassifierEClassifierCrossReference_1_0()); }
10091 { before(grammarAccess.getIntervallNumberAccess().getMaxNumberINTTerminalRuleCall_2_0_0()); } 10091 (
10092 RULE_INT 10092 { before(grammarAccess.getMetamodelElementAccess().getClassifierEClassifierIDTerminalRuleCall_1_0_1()); }
10093 { after(grammarAccess.getIntervallNumberAccess().getMaxNumberINTTerminalRuleCall_2_0_0()); } 10093 RULE_ID
10094 ) 10094 { after(grammarAccess.getMetamodelElementAccess().getClassifierEClassifierIDTerminalRuleCall_1_0_1()); }
10095; 10095 )
10096finally { 10096 { after(grammarAccess.getMetamodelElementAccess().getClassifierEClassifierCrossReference_1_0()); }
10097 restoreStackSize(stackSize); 10097 )
10098} 10098;
10099 10099finally {
10100rule__IntervallNumber__MaxUnlimitedAssignment_2_1 10100 restoreStackSize(stackSize);
10101 @init { 10101}
10102 int stackSize = keepStackSize(); 10102
10103 } 10103rule__MetamodelElement__FeatureAssignment_2_1
10104: 10104 @init {
10105 ( 10105 int stackSize = keepStackSize();
10106 { before(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); } 10106 }
10107 ( 10107:
10108 { before(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); } 10108 (
10109 '*' 10109 { before(grammarAccess.getMetamodelElementAccess().getFeatureENamedElementCrossReference_2_1_0()); }
10110 { after(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); } 10110 (
10111 ) 10111 { before(grammarAccess.getMetamodelElementAccess().getFeatureENamedElementIDTerminalRuleCall_2_1_0_1()); }
10112 { after(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); } 10112 RULE_ID
10113 ) 10113 { after(grammarAccess.getMetamodelElementAccess().getFeatureENamedElementIDTerminalRuleCall_2_1_0_1()); }
10114; 10114 )
10115finally { 10115 { after(grammarAccess.getMetamodelElementAccess().getFeatureENamedElementCrossReference_2_1_0()); }
10116 restoreStackSize(stackSize); 10116 )
10117} 10117;
10118 10118finally {
10119rule__IntEnumberation__EntryAssignment_2_0 10119 restoreStackSize(stackSize);
10120 @init { 10120}
10121 int stackSize = keepStackSize(); 10121
10122 } 10122rule__MetamodelDeclaration__NameAssignment_1
10123: 10123 @init {
10124 ( 10124 int stackSize = keepStackSize();
10125 { before(grammarAccess.getIntEnumberationAccess().getEntryINTLiteralParserRuleCall_2_0_0()); } 10125 }
10126 ruleINTLiteral 10126:
10127 { after(grammarAccess.getIntEnumberationAccess().getEntryINTLiteralParserRuleCall_2_0_0()); } 10127 (
10128 ) 10128 { before(grammarAccess.getMetamodelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
10129; 10129 RULE_ID
10130finally { 10130 { after(grammarAccess.getMetamodelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
10131 restoreStackSize(stackSize); 10131 )
10132} 10132;
10133 10133finally {
10134rule__IntEnumberation__EntryAssignment_2_1_1 10134 restoreStackSize(stackSize);
10135 @init { 10135}
10136 int stackSize = keepStackSize(); 10136
10137 } 10137rule__MetamodelDeclaration__SpecificationAssignment_2
10138: 10138 @init {
10139 ( 10139 int stackSize = keepStackSize();
10140 { before(grammarAccess.getIntEnumberationAccess().getEntryINTLiteralParserRuleCall_2_1_1_0()); } 10140 }
10141 ruleINTLiteral 10141:
10142 { after(grammarAccess.getIntEnumberationAccess().getEntryINTLiteralParserRuleCall_2_1_1_0()); } 10142 (
10143 ) 10143 { before(grammarAccess.getMetamodelDeclarationAccess().getSpecificationMetamodelSpecificationParserRuleCall_2_0()); }
10144; 10144 ruleMetamodelSpecification
10145finally { 10145 { after(grammarAccess.getMetamodelDeclarationAccess().getSpecificationMetamodelSpecificationParserRuleCall_2_0()); }
10146 restoreStackSize(stackSize); 10146 )
10147} 10147;
10148 10148finally {
10149rule__RealEnumeration__EntryAssignment_2_0 10149 restoreStackSize(stackSize);
10150 @init { 10150}
10151 int stackSize = keepStackSize(); 10151
10152 } 10152rule__MetamodelReference__ReferredAssignment
10153: 10153 @init {
10154 ( 10154 int stackSize = keepStackSize();
10155 { before(grammarAccess.getRealEnumerationAccess().getEntryREALLiteralParserRuleCall_2_0_0()); } 10155 }
10156 ruleREALLiteral 10156:
10157 { after(grammarAccess.getRealEnumerationAccess().getEntryREALLiteralParserRuleCall_2_0_0()); } 10157 (
10158 ) 10158 { before(grammarAccess.getMetamodelReferenceAccess().getReferredMetamodelDeclarationCrossReference_0()); }
10159; 10159 (
10160finally { 10160 { before(grammarAccess.getMetamodelReferenceAccess().getReferredMetamodelDeclarationIDTerminalRuleCall_0_1()); }
10161 restoreStackSize(stackSize); 10161 RULE_ID
10162} 10162 { after(grammarAccess.getMetamodelReferenceAccess().getReferredMetamodelDeclarationIDTerminalRuleCall_0_1()); }
10163 10163 )
10164rule__RealEnumeration__EntryAssignment_2_1_1 10164 { after(grammarAccess.getMetamodelReferenceAccess().getReferredMetamodelDeclarationCrossReference_0()); }
10165 @init { 10165 )
10166 int stackSize = keepStackSize(); 10166;
10167 } 10167finally {
10168: 10168 restoreStackSize(stackSize);
10169 ( 10169}
10170 { before(grammarAccess.getRealEnumerationAccess().getEntryREALLiteralParserRuleCall_2_1_1_0()); } 10170
10171 ruleREALLiteral 10171rule__PartialModelSpecification__EntryAssignment_1
10172 { after(grammarAccess.getRealEnumerationAccess().getEntryREALLiteralParserRuleCall_2_1_1_0()); } 10172 @init {
10173 ) 10173 int stackSize = keepStackSize();
10174; 10174 }
10175finally { 10175:
10176 restoreStackSize(stackSize); 10176 (
10177} 10177 { before(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_1_0()); }
10178 10178 rulePartialModelEntry
10179rule__StringEnumeration__EntryAssignment_2_0 10179 { after(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_1_0()); }
10180 @init { 10180 )
10181 int stackSize = keepStackSize(); 10181;
10182 } 10182finally {
10183: 10183 restoreStackSize(stackSize);
10184 ( 10184}
10185 { before(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_0_0()); } 10185
10186 RULE_STRING 10186rule__PartialModelSpecification__EntryAssignment_2_1
10187 { after(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_0_0()); } 10187 @init {
10188 ) 10188 int stackSize = keepStackSize();
10189; 10189 }
10190finally { 10190:
10191 restoreStackSize(stackSize); 10191 (
10192} 10192 { before(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_2_1_0()); }
10193 10193 rulePartialModelEntry
10194rule__StringEnumeration__EntryAssignment_2_1_1 10194 { after(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_2_1_0()); }
10195 @init { 10195 )
10196 int stackSize = keepStackSize(); 10196;
10197 } 10197finally {
10198: 10198 restoreStackSize(stackSize);
10199 ( 10199}
10200 { before(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_1_1_0()); } 10200
10201 RULE_STRING 10201rule__ModelEntry__PathAssignment
10202 { after(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_1_1_0()); } 10202 @init {
10203 ) 10203 int stackSize = keepStackSize();
10204; 10204 }
10205finally { 10205:
10206 restoreStackSize(stackSize); 10206 (
10207} 10207 { before(grammarAccess.getModelEntryAccess().getPathFileParserRuleCall_0()); }
10208 10208 ruleFile
10209rule__ScopeDeclaration__NameAssignment_1 10209 { after(grammarAccess.getModelEntryAccess().getPathFileParserRuleCall_0()); }
10210 @init { 10210 )
10211 int stackSize = keepStackSize(); 10211;
10212 } 10212finally {
10213: 10213 restoreStackSize(stackSize);
10214 ( 10214}
10215 { before(grammarAccess.getScopeDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 10215
10216 RULE_ID 10216rule__FolderEntry__PathAssignment_1
10217 { after(grammarAccess.getScopeDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } 10217 @init {
10218 ) 10218 int stackSize = keepStackSize();
10219; 10219 }
10220finally { 10220:
10221 restoreStackSize(stackSize); 10221 (
10222} 10222 { before(grammarAccess.getFolderEntryAccess().getPathFileParserRuleCall_1_0()); }
10223 10223 ruleFile
10224rule__ScopeDeclaration__SpecificationAssignment_2 10224 { after(grammarAccess.getFolderEntryAccess().getPathFileParserRuleCall_1_0()); }
10225 @init { 10225 )
10226 int stackSize = keepStackSize(); 10226;
10227 } 10227finally {
10228: 10228 restoreStackSize(stackSize);
10229 ( 10229}
10230 { before(grammarAccess.getScopeDeclarationAccess().getSpecificationScopeSpecificationParserRuleCall_2_0()); } 10230
10231 ruleScopeSpecification 10231rule__FolderEntry__ExclusionAssignment_2_2
10232 { after(grammarAccess.getScopeDeclarationAccess().getSpecificationScopeSpecificationParserRuleCall_2_0()); } 10232 @init {
10233 ) 10233 int stackSize = keepStackSize();
10234; 10234 }
10235finally { 10235:
10236 restoreStackSize(stackSize); 10236 (
10237} 10237 { before(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_2_0()); }
10238 10238 ruleModelEntry
10239rule__ScopeReference__ReferredAssignment 10239 { after(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_2_0()); }
10240 @init { 10240 )
10241 int stackSize = keepStackSize(); 10241;
10242 } 10242finally {
10243: 10243 restoreStackSize(stackSize);
10244 ( 10244}
10245 { before(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationCrossReference_0()); } 10245
10246 ( 10246rule__FolderEntry__ExclusionAssignment_2_3_1
10247 { before(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationIDTerminalRuleCall_0_1()); } 10247 @init {
10248 RULE_ID 10248 int stackSize = keepStackSize();
10249 { after(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationIDTerminalRuleCall_0_1()); } 10249 }
10250 ) 10250:
10251 { after(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationCrossReference_0()); } 10251 (
10252 ) 10252 { before(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_3_1_0()); }
10253; 10253 ruleModelEntry
10254finally { 10254 { after(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_3_1_0()); }
10255 restoreStackSize(stackSize); 10255 )
10256} 10256;
10257 10257finally {
10258rule__GenerationTask__MetamodelAssignment_3_0_2 10258 restoreStackSize(stackSize);
10259 @init { 10259}
10260 int stackSize = keepStackSize(); 10260
10261 } 10261rule__PartialModelDeclaration__NameAssignment_1
10262: 10262 @init {
10263 ( 10263 int stackSize = keepStackSize();
10264 { before(grammarAccess.getGenerationTaskAccess().getMetamodelMetamodelParserRuleCall_3_0_2_0()); } 10264 }
10265 ruleMetamodel 10265:
10266 { after(grammarAccess.getGenerationTaskAccess().getMetamodelMetamodelParserRuleCall_3_0_2_0()); } 10266 (
10267 ) 10267 { before(grammarAccess.getPartialModelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
10268; 10268 RULE_ID
10269finally { 10269 { after(grammarAccess.getPartialModelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
10270 restoreStackSize(stackSize); 10270 )
10271} 10271;
10272 10272finally {
10273rule__GenerationTask__PartialModelAssignment_3_1_2 10273 restoreStackSize(stackSize);
10274 @init { 10274}
10275 int stackSize = keepStackSize(); 10275
10276 } 10276rule__PartialModelDeclaration__SpecificationAssignment_2
10277: 10277 @init {
10278 ( 10278 int stackSize = keepStackSize();
10279 { before(grammarAccess.getGenerationTaskAccess().getPartialModelPartialModelParserRuleCall_3_1_2_0()); } 10279 }
10280 rulePartialModel 10280:
10281 { after(grammarAccess.getGenerationTaskAccess().getPartialModelPartialModelParserRuleCall_3_1_2_0()); } 10281 (
10282 ) 10282 { before(grammarAccess.getPartialModelDeclarationAccess().getSpecificationPartialModelSpecificationParserRuleCall_2_0()); }
10283; 10283 rulePartialModelSpecification
10284finally { 10284 { after(grammarAccess.getPartialModelDeclarationAccess().getSpecificationPartialModelSpecificationParserRuleCall_2_0()); }
10285 restoreStackSize(stackSize); 10285 )
10286} 10286;
10287 10287finally {
10288rule__GenerationTask__PatternsAssignment_3_2_2 10288 restoreStackSize(stackSize);
10289 @init { 10289}
10290 int stackSize = keepStackSize(); 10290
10291 } 10291rule__PartialModelReference__ReferredAssignment
10292: 10292 @init {
10293 ( 10293 int stackSize = keepStackSize();
10294 { before(grammarAccess.getGenerationTaskAccess().getPatternsGraphPatternParserRuleCall_3_2_2_0()); } 10294 }
10295 ruleGraphPattern 10295:
10296 { after(grammarAccess.getGenerationTaskAccess().getPatternsGraphPatternParserRuleCall_3_2_2_0()); } 10296 (
10297 ) 10297 { before(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationCrossReference_0()); }
10298; 10298 (
10299finally { 10299 { before(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationIDTerminalRuleCall_0_1()); }
10300 restoreStackSize(stackSize); 10300 RULE_ID
10301} 10301 { after(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationIDTerminalRuleCall_0_1()); }
10302 10302 )
10303rule__GenerationTask__ScopeAssignment_3_3_2 10303 { after(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationCrossReference_0()); }
10304 @init { 10304 )
10305 int stackSize = keepStackSize(); 10305;
10306 } 10306finally {
10307: 10307 restoreStackSize(stackSize);
10308 ( 10308}
10309 { before(grammarAccess.getGenerationTaskAccess().getScopeScopeParserRuleCall_3_3_2_0()); } 10309
10310 ruleScope 10310rule__PatternSpecification__EntriesAssignment_1
10311 { after(grammarAccess.getGenerationTaskAccess().getScopeScopeParserRuleCall_3_3_2_0()); } 10311 @init {
10312 ) 10312 int stackSize = keepStackSize();
10313; 10313 }
10314finally { 10314:
10315 restoreStackSize(stackSize); 10315 (
10316} 10316 { before(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_1_0()); }
10317 10317 rulePatternEntry
10318rule__GenerationTask__NumberSpecifiedAssignment_3_4_0 10318 { after(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_1_0()); }
10319 @init { 10319 )
10320 int stackSize = keepStackSize(); 10320;
10321 } 10321finally {
10322: 10322 restoreStackSize(stackSize);
10323 ( 10323}
10324 { before(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_4_0_0()); } 10324
10325 ( 10325rule__PatternSpecification__EntriesAssignment_2_1
10326 { before(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_4_0_0()); } 10326 @init {
10327 'number' 10327 int stackSize = keepStackSize();
10328 { after(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_4_0_0()); } 10328 }
10329 ) 10329:
10330 { after(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_4_0_0()); } 10330 (
10331 ) 10331 { before(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_2_1_0()); }
10332; 10332 rulePatternEntry
10333finally { 10333 { after(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_2_1_0()); }
10334 restoreStackSize(stackSize); 10334 )
10335} 10335;
10336 10336finally {
10337rule__GenerationTask__NumberAssignment_3_4_2 10337 restoreStackSize(stackSize);
10338 @init { 10338}
10339 int stackSize = keepStackSize(); 10339
10340 } 10340rule__AllPatternEntry__PackageAssignment_1
10341: 10341 @init {
10342 ( 10342 int stackSize = keepStackSize();
10343 { before(grammarAccess.getGenerationTaskAccess().getNumberINTTerminalRuleCall_3_4_2_0()); } 10343 }
10344 RULE_INT 10344:
10345 { after(grammarAccess.getGenerationTaskAccess().getNumberINTTerminalRuleCall_3_4_2_0()); } 10345 (
10346 ) 10346 { before(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelCrossReference_1_0()); }
10347; 10347 (
10348finally { 10348 { before(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelQualifiedNameParserRuleCall_1_0_1()); }
10349 restoreStackSize(stackSize); 10349 ruleQualifiedName
10350} 10350 { after(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelQualifiedNameParserRuleCall_1_0_1()); }
10351 10351 )
10352rule__GenerationTask__RunSpecifiedAssignment_3_5_0 10352 { after(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelCrossReference_1_0()); }
10353 @init { 10353 )
10354 int stackSize = keepStackSize(); 10354;
10355 } 10355finally {
10356: 10356 restoreStackSize(stackSize);
10357 ( 10357}
10358 { before(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_5_0_0()); } 10358
10359 ( 10359rule__AllPatternEntry__ExclusuionAssignment_2_2
10360 { before(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_5_0_0()); } 10360 @init {
10361 'runs' 10361 int stackSize = keepStackSize();
10362 { after(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_5_0_0()); } 10362 }
10363 ) 10363:
10364 { after(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_5_0_0()); } 10364 (
10365 ) 10365 { before(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_2_0()); }
10366; 10366 rulePatternElement
10367finally { 10367 { after(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_2_0()); }
10368 restoreStackSize(stackSize); 10368 )
10369} 10369;
10370 10370finally {
10371rule__GenerationTask__RunsAssignment_3_5_2 10371 restoreStackSize(stackSize);
10372 @init { 10372}
10373 int stackSize = keepStackSize(); 10373
10374 } 10374rule__AllPatternEntry__ExclusuionAssignment_2_3_1
10375: 10375 @init {
10376 ( 10376 int stackSize = keepStackSize();
10377 { before(grammarAccess.getGenerationTaskAccess().getRunsINTTerminalRuleCall_3_5_2_0()); } 10377 }
10378 RULE_INT 10378:
10379 { after(grammarAccess.getGenerationTaskAccess().getRunsINTTerminalRuleCall_3_5_2_0()); } 10379 (
10380 ) 10380 { before(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_3_1_0()); }
10381; 10381 rulePatternElement
10382finally { 10382 { after(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_3_1_0()); }
10383 restoreStackSize(stackSize); 10383 )
10384} 10384;
10385 10385finally {
10386rule__GenerationTask__SolverAssignment_3_6_2 10386 restoreStackSize(stackSize);
10387 @init { 10387}
10388 int stackSize = keepStackSize(); 10388
10389 } 10389rule__PatternElement__PackageAssignment_0_0
10390: 10390 @init {
10391 ( 10391 int stackSize = keepStackSize();
10392 { before(grammarAccess.getGenerationTaskAccess().getSolverSolverEnumRuleCall_3_6_2_0()); } 10392 }
10393 ruleSolver 10393:
10394 { after(grammarAccess.getGenerationTaskAccess().getSolverSolverEnumRuleCall_3_6_2_0()); } 10394 (
10395 ) 10395 { before(grammarAccess.getPatternElementAccess().getPackagePatternModelCrossReference_0_0_0()); }
10396; 10396 (
10397finally { 10397 { before(grammarAccess.getPatternElementAccess().getPackagePatternModelQualifiedNameParserRuleCall_0_0_0_1()); }
10398 restoreStackSize(stackSize); 10398 ruleQualifiedName
10399} 10399 { after(grammarAccess.getPatternElementAccess().getPackagePatternModelQualifiedNameParserRuleCall_0_0_0_1()); }
10400 10400 )
10401rule__GenerationTask__ConfigAssignment_3_7_2 10401 { after(grammarAccess.getPatternElementAccess().getPackagePatternModelCrossReference_0_0_0()); }
10402 @init { 10402 )
10403 int stackSize = keepStackSize(); 10403;
10404 } 10404finally {
10405: 10405 restoreStackSize(stackSize);
10406 ( 10406}
10407 { before(grammarAccess.getGenerationTaskAccess().getConfigConfigParserRuleCall_3_7_2_0()); } 10407
10408 ruleConfig 10408rule__PatternElement__PatternAssignment_1
10409 { after(grammarAccess.getGenerationTaskAccess().getConfigConfigParserRuleCall_3_7_2_0()); } 10409 @init {
10410 ) 10410 int stackSize = keepStackSize();
10411; 10411 }
10412finally { 10412:
10413 restoreStackSize(stackSize); 10413 (
10414} 10414 { before(grammarAccess.getPatternElementAccess().getPatternPatternCrossReference_1_0()); }
10415 10415 (
10416rule__GenerationTask__DebugFolderAssignment_3_8_2 10416 { before(grammarAccess.getPatternElementAccess().getPatternPatternIDTerminalRuleCall_1_0_1()); }
10417 @init { 10417 RULE_ID
10418 int stackSize = keepStackSize(); 10418 { after(grammarAccess.getPatternElementAccess().getPatternPatternIDTerminalRuleCall_1_0_1()); }
10419 } 10419 )
10420: 10420 { after(grammarAccess.getPatternElementAccess().getPatternPatternCrossReference_1_0()); }
10421 ( 10421 )
10422 { before(grammarAccess.getGenerationTaskAccess().getDebugFolderFileParserRuleCall_3_8_2_0()); } 10422;
10423 ruleFile 10423finally {
10424 { after(grammarAccess.getGenerationTaskAccess().getDebugFolderFileParserRuleCall_3_8_2_0()); } 10424 restoreStackSize(stackSize);
10425 ) 10425}
10426; 10426
10427finally { 10427rule__GraphPatternDeclaration__NameAssignment_1
10428 restoreStackSize(stackSize); 10428 @init {
10429} 10429 int stackSize = keepStackSize();
10430 10430 }
10431rule__GenerationTask__TargetLogFileAssignment_3_9_2 10431:
10432 @init { 10432 (
10433 int stackSize = keepStackSize(); 10433 { before(grammarAccess.getGraphPatternDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
10434 } 10434 RULE_ID
10435: 10435 { after(grammarAccess.getGraphPatternDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
10436 ( 10436 )
10437 { before(grammarAccess.getGenerationTaskAccess().getTargetLogFileFileParserRuleCall_3_9_2_0()); } 10437;
10438 ruleFile 10438finally {
10439 { after(grammarAccess.getGenerationTaskAccess().getTargetLogFileFileParserRuleCall_3_9_2_0()); } 10439 restoreStackSize(stackSize);
10440 ) 10440}
10441; 10441
10442finally { 10442rule__GraphPatternDeclaration__SpecificationAssignment_2
10443 restoreStackSize(stackSize); 10443 @init {
10444} 10444 int stackSize = keepStackSize();
10445 10445 }
10446rule__GenerationTask__TargetStatisticsFileAssignment_3_10_2 10446:
10447 @init { 10447 (
10448 int stackSize = keepStackSize(); 10448 { before(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationPatternSpecificationParserRuleCall_2_0()); }
10449 } 10449 rulePatternSpecification
10450: 10450 { after(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationPatternSpecificationParserRuleCall_2_0()); }
10451 ( 10451 )
10452 { before(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileFileParserRuleCall_3_10_2_0()); } 10452;
10453 ruleFile 10453finally {
10454 { after(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileFileParserRuleCall_3_10_2_0()); } 10454 restoreStackSize(stackSize);
10455 ) 10455}
10456; 10456
10457finally { 10457rule__GraphPatternReference__ReferredAssignment
10458 restoreStackSize(stackSize); 10458 @init {
10459} 10459 int stackSize = keepStackSize();
10460 10460 }
10461rule__GenerationTask__TagetFolderAssignment_3_11_2 10461:
10462 @init { 10462 (
10463 int stackSize = keepStackSize(); 10463 { before(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationCrossReference_0()); }
10464 } 10464 (
10465: 10465 { before(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationIDTerminalRuleCall_0_1()); }
10466 ( 10466 RULE_ID
10467 { before(grammarAccess.getGenerationTaskAccess().getTagetFolderFileParserRuleCall_3_11_2_0()); } 10467 { after(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationIDTerminalRuleCall_0_1()); }
10468 ruleFile 10468 )
10469 { after(grammarAccess.getGenerationTaskAccess().getTagetFolderFileParserRuleCall_3_11_2_0()); } 10469 { after(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationCrossReference_0()); }
10470 ) 10470 )
10471; 10471;
10472finally { 10472finally {
10473 restoreStackSize(stackSize); 10473 restoreStackSize(stackSize);
10474} 10474}
10475 10475
10476RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; 10476rule__ObjectiveSpecification__EntriesAssignment_1
10477 10477 @init {
10478RULE_INT : ('0'..'9')+; 10478 int stackSize = keepStackSize();
10479 10479 }
10480RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); 10480:
10481 10481 (
10482RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; 10482 { before(grammarAccess.getObjectiveSpecificationAccess().getEntriesObjectiveEntryParserRuleCall_1_0()); }
10483 10483 ruleObjectiveEntry
10484RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; 10484 { after(grammarAccess.getObjectiveSpecificationAccess().getEntriesObjectiveEntryParserRuleCall_1_0()); }
10485 10485 )
10486RULE_WS : (' '|'\t'|'\r'|'\n')+; 10486;
10487 10487finally {
10488RULE_ANY_OTHER : .; 10488 restoreStackSize(stackSize);
10489}
10490
10491rule__ObjectiveSpecification__EntriesAssignment_2_1
10492 @init {
10493 int stackSize = keepStackSize();
10494 }
10495:
10496 (
10497 { before(grammarAccess.getObjectiveSpecificationAccess().getEntriesObjectiveEntryParserRuleCall_2_1_0()); }
10498 ruleObjectiveEntry
10499 { after(grammarAccess.getObjectiveSpecificationAccess().getEntriesObjectiveEntryParserRuleCall_2_1_0()); }
10500 )
10501;
10502finally {
10503 restoreStackSize(stackSize);
10504}
10505
10506rule__OptimizationEntry__DirectionAssignment_0
10507 @init {
10508 int stackSize = keepStackSize();
10509 }
10510:
10511 (
10512 { before(grammarAccess.getOptimizationEntryAccess().getDirectionOptimizationDirectionEnumRuleCall_0_0()); }
10513 ruleOptimizationDirection
10514 { after(grammarAccess.getOptimizationEntryAccess().getDirectionOptimizationDirectionEnumRuleCall_0_0()); }
10515 )
10516;
10517finally {
10518 restoreStackSize(stackSize);
10519}
10520
10521rule__OptimizationEntry__FunctionAssignment_1
10522 @init {
10523 int stackSize = keepStackSize();
10524 }
10525:
10526 (
10527 { before(grammarAccess.getOptimizationEntryAccess().getFunctionObjectiveFunctionParserRuleCall_1_0()); }
10528 ruleObjectiveFunction
10529 { after(grammarAccess.getOptimizationEntryAccess().getFunctionObjectiveFunctionParserRuleCall_1_0()); }
10530 )
10531;
10532finally {
10533 restoreStackSize(stackSize);
10534}
10535
10536rule__ThresholdEntry__FunctionAssignment_0
10537 @init {
10538 int stackSize = keepStackSize();
10539 }
10540:
10541 (
10542 { before(grammarAccess.getThresholdEntryAccess().getFunctionObjectiveFunctionParserRuleCall_0_0()); }
10543 ruleObjectiveFunction
10544 { after(grammarAccess.getThresholdEntryAccess().getFunctionObjectiveFunctionParserRuleCall_0_0()); }
10545 )
10546;
10547finally {
10548 restoreStackSize(stackSize);
10549}
10550
10551rule__ThresholdEntry__OperatorAssignment_1
10552 @init {
10553 int stackSize = keepStackSize();
10554 }
10555:
10556 (
10557 { before(grammarAccess.getThresholdEntryAccess().getOperatorComparisonOperatorEnumRuleCall_1_0()); }
10558 ruleComparisonOperator
10559 { after(grammarAccess.getThresholdEntryAccess().getOperatorComparisonOperatorEnumRuleCall_1_0()); }
10560 )
10561;
10562finally {
10563 restoreStackSize(stackSize);
10564}
10565
10566rule__ThresholdEntry__ThresholdAssignment_2
10567 @init {
10568 int stackSize = keepStackSize();
10569 }
10570:
10571 (
10572 { before(grammarAccess.getThresholdEntryAccess().getThresholdREALLiteralParserRuleCall_2_0()); }
10573 ruleREALLiteral
10574 { after(grammarAccess.getThresholdEntryAccess().getThresholdREALLiteralParserRuleCall_2_0()); }
10575 )
10576;
10577finally {
10578 restoreStackSize(stackSize);
10579}
10580
10581rule__ReliabiltiyFunction__PackageAssignment_1_0
10582 @init {
10583 int stackSize = keepStackSize();
10584 }
10585:
10586 (
10587 { before(grammarAccess.getReliabiltiyFunctionAccess().getPackageCftModelCrossReference_1_0_0()); }
10588 (
10589 { before(grammarAccess.getReliabiltiyFunctionAccess().getPackageCftModelQualifiedNameParserRuleCall_1_0_0_1()); }
10590 ruleQualifiedName
10591 { after(grammarAccess.getReliabiltiyFunctionAccess().getPackageCftModelQualifiedNameParserRuleCall_1_0_0_1()); }
10592 )
10593 { after(grammarAccess.getReliabiltiyFunctionAccess().getPackageCftModelCrossReference_1_0_0()); }
10594 )
10595;
10596finally {
10597 restoreStackSize(stackSize);
10598}
10599
10600rule__ReliabiltiyFunction__TransformationAssignment_2
10601 @init {
10602 int stackSize = keepStackSize();
10603 }
10604:
10605 (
10606 { before(grammarAccess.getReliabiltiyFunctionAccess().getTransformationTransformationDefinitionCrossReference_2_0()); }
10607 (
10608 { before(grammarAccess.getReliabiltiyFunctionAccess().getTransformationTransformationDefinitionIDTerminalRuleCall_2_0_1()); }
10609 RULE_ID
10610 { after(grammarAccess.getReliabiltiyFunctionAccess().getTransformationTransformationDefinitionIDTerminalRuleCall_2_0_1()); }
10611 )
10612 { after(grammarAccess.getReliabiltiyFunctionAccess().getTransformationTransformationDefinitionCrossReference_2_0()); }
10613 )
10614;
10615finally {
10616 restoreStackSize(stackSize);
10617}
10618
10619rule__ObjectiveDeclaration__NameAssignment_1
10620 @init {
10621 int stackSize = keepStackSize();
10622 }
10623:
10624 (
10625 { before(grammarAccess.getObjectiveDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
10626 RULE_ID
10627 { after(grammarAccess.getObjectiveDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
10628 )
10629;
10630finally {
10631 restoreStackSize(stackSize);
10632}
10633
10634rule__ObjectiveDeclaration__SpecificationAssignment_2
10635 @init {
10636 int stackSize = keepStackSize();
10637 }
10638:
10639 (
10640 { before(grammarAccess.getObjectiveDeclarationAccess().getSpecificationObjectiveSpecificationParserRuleCall_2_0()); }
10641 ruleObjectiveSpecification
10642 { after(grammarAccess.getObjectiveDeclarationAccess().getSpecificationObjectiveSpecificationParserRuleCall_2_0()); }
10643 )
10644;
10645finally {
10646 restoreStackSize(stackSize);
10647}
10648
10649rule__ObjectiveReference__ReferredAssignment
10650 @init {
10651 int stackSize = keepStackSize();
10652 }
10653:
10654 (
10655 { before(grammarAccess.getObjectiveReferenceAccess().getReferredObjectiveDeclarationCrossReference_0()); }
10656 (
10657 { before(grammarAccess.getObjectiveReferenceAccess().getReferredObjectiveDeclarationIDTerminalRuleCall_0_1()); }
10658 RULE_ID
10659 { after(grammarAccess.getObjectiveReferenceAccess().getReferredObjectiveDeclarationIDTerminalRuleCall_0_1()); }
10660 )
10661 { after(grammarAccess.getObjectiveReferenceAccess().getReferredObjectiveDeclarationCrossReference_0()); }
10662 )
10663;
10664finally {
10665 restoreStackSize(stackSize);
10666}
10667
10668rule__ConfigSpecification__EntriesAssignment_2_0
10669 @init {
10670 int stackSize = keepStackSize();
10671 }
10672:
10673 (
10674 { before(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_0_0()); }
10675 ruleConfigEntry
10676 { after(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_0_0()); }
10677 )
10678;
10679finally {
10680 restoreStackSize(stackSize);
10681}
10682
10683rule__ConfigSpecification__EntriesAssignment_2_1_1
10684 @init {
10685 int stackSize = keepStackSize();
10686 }
10687:
10688 (
10689 { before(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_1_1_0()); }
10690 ruleConfigEntry
10691 { after(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_1_1_0()); }
10692 )
10693;
10694finally {
10695 restoreStackSize(stackSize);
10696}
10697
10698rule__ConfigDeclaration__NameAssignment_1
10699 @init {
10700 int stackSize = keepStackSize();
10701 }
10702:
10703 (
10704 { before(grammarAccess.getConfigDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
10705 RULE_ID
10706 { after(grammarAccess.getConfigDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
10707 )
10708;
10709finally {
10710 restoreStackSize(stackSize);
10711}
10712
10713rule__ConfigDeclaration__SpecificationAssignment_2
10714 @init {
10715 int stackSize = keepStackSize();
10716 }
10717:
10718 (
10719 { before(grammarAccess.getConfigDeclarationAccess().getSpecificationConfigSpecificationParserRuleCall_2_0()); }
10720 ruleConfigSpecification
10721 { after(grammarAccess.getConfigDeclarationAccess().getSpecificationConfigSpecificationParserRuleCall_2_0()); }
10722 )
10723;
10724finally {
10725 restoreStackSize(stackSize);
10726}
10727
10728rule__DocumentationEntry__LevelAssignment_2
10729 @init {
10730 int stackSize = keepStackSize();
10731 }
10732:
10733 (
10734 { before(grammarAccess.getDocumentationEntryAccess().getLevelDocumentLevelSpecificationEnumRuleCall_2_0()); }
10735 ruleDocumentLevelSpecification
10736 { after(grammarAccess.getDocumentationEntryAccess().getLevelDocumentLevelSpecificationEnumRuleCall_2_0()); }
10737 )
10738;
10739finally {
10740 restoreStackSize(stackSize);
10741}
10742
10743rule__RuntimeEntry__MillisecLimitAssignment_2
10744 @init {
10745 int stackSize = keepStackSize();
10746 }
10747:
10748 (
10749 { before(grammarAccess.getRuntimeEntryAccess().getMillisecLimitINTTerminalRuleCall_2_0()); }
10750 RULE_INT
10751 { after(grammarAccess.getRuntimeEntryAccess().getMillisecLimitINTTerminalRuleCall_2_0()); }
10752 )
10753;
10754finally {
10755 restoreStackSize(stackSize);
10756}
10757
10758rule__MemoryEntry__MegabyteLimitAssignment_2
10759 @init {
10760 int stackSize = keepStackSize();
10761 }
10762:
10763 (
10764 { before(grammarAccess.getMemoryEntryAccess().getMegabyteLimitINTTerminalRuleCall_2_0()); }
10765 RULE_INT
10766 { after(grammarAccess.getMemoryEntryAccess().getMegabyteLimitINTTerminalRuleCall_2_0()); }
10767 )
10768;
10769finally {
10770 restoreStackSize(stackSize);
10771}
10772
10773rule__CustomEntry__KeyAssignment_0
10774 @init {
10775 int stackSize = keepStackSize();
10776 }
10777:
10778 (
10779 { before(grammarAccess.getCustomEntryAccess().getKeySTRINGTerminalRuleCall_0_0()); }
10780 RULE_STRING
10781 { after(grammarAccess.getCustomEntryAccess().getKeySTRINGTerminalRuleCall_0_0()); }
10782 )
10783;
10784finally {
10785 restoreStackSize(stackSize);
10786}
10787
10788rule__CustomEntry__ValueAssignment_2
10789 @init {
10790 int stackSize = keepStackSize();
10791 }
10792:
10793 (
10794 { before(grammarAccess.getCustomEntryAccess().getValueSTRINGTerminalRuleCall_2_0()); }
10795 RULE_STRING
10796 { after(grammarAccess.getCustomEntryAccess().getValueSTRINGTerminalRuleCall_2_0()); }
10797 )
10798;
10799finally {
10800 restoreStackSize(stackSize);
10801}
10802
10803rule__ConfigReference__ConfigAssignment
10804 @init {
10805 int stackSize = keepStackSize();
10806 }
10807:
10808 (
10809 { before(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationCrossReference_0()); }
10810 (
10811 { before(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationIDTerminalRuleCall_0_1()); }
10812 RULE_ID
10813 { after(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationIDTerminalRuleCall_0_1()); }
10814 )
10815 { after(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationCrossReference_0()); }
10816 )
10817;
10818finally {
10819 restoreStackSize(stackSize);
10820}
10821
10822rule__ScopeSpecification__ScopesAssignment_2_0
10823 @init {
10824 int stackSize = keepStackSize();
10825 }
10826:
10827 (
10828 { before(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_0_0()); }
10829 ruleTypeScope
10830 { after(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_0_0()); }
10831 )
10832;
10833finally {
10834 restoreStackSize(stackSize);
10835}
10836
10837rule__ScopeSpecification__ScopesAssignment_2_1_1
10838 @init {
10839 int stackSize = keepStackSize();
10840 }
10841:
10842 (
10843 { before(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_1_1_0()); }
10844 ruleTypeScope
10845 { after(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_1_1_0()); }
10846 )
10847;
10848finally {
10849 restoreStackSize(stackSize);
10850}
10851
10852rule__ClassTypeScope__TypeAssignment_1
10853 @init {
10854 int stackSize = keepStackSize();
10855 }
10856:
10857 (
10858 { before(grammarAccess.getClassTypeScopeAccess().getTypeClassReferenceParserRuleCall_1_0()); }
10859 ruleClassReference
10860 { after(grammarAccess.getClassTypeScopeAccess().getTypeClassReferenceParserRuleCall_1_0()); }
10861 )
10862;
10863finally {
10864 restoreStackSize(stackSize);
10865}
10866
10867rule__ClassTypeScope__SetsNewAssignment_2_0
10868 @init {
10869 int stackSize = keepStackSize();
10870 }
10871:
10872 (
10873 { before(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
10874 (
10875 { before(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
10876 '+='
10877 { after(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
10878 )
10879 { after(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
10880 )
10881;
10882finally {
10883 restoreStackSize(stackSize);
10884}
10885
10886rule__ClassTypeScope__SetsSumAssignment_2_1
10887 @init {
10888 int stackSize = keepStackSize();
10889 }
10890:
10891 (
10892 { before(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
10893 (
10894 { before(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
10895 '='
10896 { after(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
10897 )
10898 { after(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
10899 )
10900;
10901finally {
10902 restoreStackSize(stackSize);
10903}
10904
10905rule__ClassTypeScope__NumberAssignment_3_0
10906 @init {
10907 int stackSize = keepStackSize();
10908 }
10909:
10910 (
10911 { before(grammarAccess.getClassTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); }
10912 ruleExactNumber
10913 { after(grammarAccess.getClassTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); }
10914 )
10915;
10916finally {
10917 restoreStackSize(stackSize);
10918}
10919
10920rule__ClassTypeScope__NumberAssignment_3_1
10921 @init {
10922 int stackSize = keepStackSize();
10923 }
10924:
10925 (
10926 { before(grammarAccess.getClassTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); }
10927 ruleIntervallNumber
10928 { after(grammarAccess.getClassTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); }
10929 )
10930;
10931finally {
10932 restoreStackSize(stackSize);
10933}
10934
10935rule__ObjectTypeScope__TypeAssignment_1
10936 @init {
10937 int stackSize = keepStackSize();
10938 }
10939:
10940 (
10941 { before(grammarAccess.getObjectTypeScopeAccess().getTypeObjectReferenceParserRuleCall_1_0()); }
10942 ruleObjectReference
10943 { after(grammarAccess.getObjectTypeScopeAccess().getTypeObjectReferenceParserRuleCall_1_0()); }
10944 )
10945;
10946finally {
10947 restoreStackSize(stackSize);
10948}
10949
10950rule__ObjectTypeScope__SetsNewAssignment_2_0
10951 @init {
10952 int stackSize = keepStackSize();
10953 }
10954:
10955 (
10956 { before(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
10957 (
10958 { before(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
10959 '+='
10960 { after(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
10961 )
10962 { after(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
10963 )
10964;
10965finally {
10966 restoreStackSize(stackSize);
10967}
10968
10969rule__ObjectTypeScope__SetsSumAssignment_2_1
10970 @init {
10971 int stackSize = keepStackSize();
10972 }
10973:
10974 (
10975 { before(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
10976 (
10977 { before(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
10978 '='
10979 { after(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
10980 )
10981 { after(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
10982 )
10983;
10984finally {
10985 restoreStackSize(stackSize);
10986}
10987
10988rule__ObjectTypeScope__NumberAssignment_3_0
10989 @init {
10990 int stackSize = keepStackSize();
10991 }
10992:
10993 (
10994 { before(grammarAccess.getObjectTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); }
10995 ruleExactNumber
10996 { after(grammarAccess.getObjectTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); }
10997 )
10998;
10999finally {
11000 restoreStackSize(stackSize);
11001}
11002
11003rule__ObjectTypeScope__NumberAssignment_3_1
11004 @init {
11005 int stackSize = keepStackSize();
11006 }
11007:
11008 (
11009 { before(grammarAccess.getObjectTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); }
11010 ruleIntervallNumber
11011 { after(grammarAccess.getObjectTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); }
11012 )
11013;
11014finally {
11015 restoreStackSize(stackSize);
11016}
11017
11018rule__IntegerTypeScope__TypeAssignment_1
11019 @init {
11020 int stackSize = keepStackSize();
11021 }
11022:
11023 (
11024 { before(grammarAccess.getIntegerTypeScopeAccess().getTypeIntegerReferenceParserRuleCall_1_0()); }
11025 ruleIntegerReference
11026 { after(grammarAccess.getIntegerTypeScopeAccess().getTypeIntegerReferenceParserRuleCall_1_0()); }
11027 )
11028;
11029finally {
11030 restoreStackSize(stackSize);
11031}
11032
11033rule__IntegerTypeScope__SetsNewAssignment_2_0
11034 @init {
11035 int stackSize = keepStackSize();
11036 }
11037:
11038 (
11039 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11040 (
11041 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11042 '+='
11043 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11044 )
11045 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11046 )
11047;
11048finally {
11049 restoreStackSize(stackSize);
11050}
11051
11052rule__IntegerTypeScope__SetsSumAssignment_2_1
11053 @init {
11054 int stackSize = keepStackSize();
11055 }
11056:
11057 (
11058 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11059 (
11060 { before(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11061 '='
11062 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11063 )
11064 { after(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11065 )
11066;
11067finally {
11068 restoreStackSize(stackSize);
11069}
11070
11071rule__IntegerTypeScope__NumberAssignment_3_0
11072 @init {
11073 int stackSize = keepStackSize();
11074 }
11075:
11076 (
11077 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); }
11078 ruleExactNumber
11079 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); }
11080 )
11081;
11082finally {
11083 restoreStackSize(stackSize);
11084}
11085
11086rule__IntegerTypeScope__NumberAssignment_3_1
11087 @init {
11088 int stackSize = keepStackSize();
11089 }
11090:
11091 (
11092 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); }
11093 ruleIntervallNumber
11094 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); }
11095 )
11096;
11097finally {
11098 restoreStackSize(stackSize);
11099}
11100
11101rule__IntegerTypeScope__NumberAssignment_3_2
11102 @init {
11103 int stackSize = keepStackSize();
11104 }
11105:
11106 (
11107 { before(grammarAccess.getIntegerTypeScopeAccess().getNumberIntEnumberationParserRuleCall_3_2_0()); }
11108 ruleIntEnumberation
11109 { after(grammarAccess.getIntegerTypeScopeAccess().getNumberIntEnumberationParserRuleCall_3_2_0()); }
11110 )
11111;
11112finally {
11113 restoreStackSize(stackSize);
11114}
11115
11116rule__RealTypeScope__TypeAssignment_1
11117 @init {
11118 int stackSize = keepStackSize();
11119 }
11120:
11121 (
11122 { before(grammarAccess.getRealTypeScopeAccess().getTypeRealReferenceParserRuleCall_1_0()); }
11123 ruleRealReference
11124 { after(grammarAccess.getRealTypeScopeAccess().getTypeRealReferenceParserRuleCall_1_0()); }
11125 )
11126;
11127finally {
11128 restoreStackSize(stackSize);
11129}
11130
11131rule__RealTypeScope__SetsNewAssignment_2_0
11132 @init {
11133 int stackSize = keepStackSize();
11134 }
11135:
11136 (
11137 { before(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11138 (
11139 { before(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11140 '+='
11141 { after(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11142 )
11143 { after(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11144 )
11145;
11146finally {
11147 restoreStackSize(stackSize);
11148}
11149
11150rule__RealTypeScope__SetsSumAssignment_2_1
11151 @init {
11152 int stackSize = keepStackSize();
11153 }
11154:
11155 (
11156 { before(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11157 (
11158 { before(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11159 '='
11160 { after(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11161 )
11162 { after(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11163 )
11164;
11165finally {
11166 restoreStackSize(stackSize);
11167}
11168
11169rule__RealTypeScope__NumberAssignment_3_0
11170 @init {
11171 int stackSize = keepStackSize();
11172 }
11173:
11174 (
11175 { before(grammarAccess.getRealTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); }
11176 ruleExactNumber
11177 { after(grammarAccess.getRealTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); }
11178 )
11179;
11180finally {
11181 restoreStackSize(stackSize);
11182}
11183
11184rule__RealTypeScope__NumberAssignment_3_1
11185 @init {
11186 int stackSize = keepStackSize();
11187 }
11188:
11189 (
11190 { before(grammarAccess.getRealTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); }
11191 ruleIntervallNumber
11192 { after(grammarAccess.getRealTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); }
11193 )
11194;
11195finally {
11196 restoreStackSize(stackSize);
11197}
11198
11199rule__RealTypeScope__NumberAssignment_3_2
11200 @init {
11201 int stackSize = keepStackSize();
11202 }
11203:
11204 (
11205 { before(grammarAccess.getRealTypeScopeAccess().getNumberRealEnumerationParserRuleCall_3_2_0()); }
11206 ruleRealEnumeration
11207 { after(grammarAccess.getRealTypeScopeAccess().getNumberRealEnumerationParserRuleCall_3_2_0()); }
11208 )
11209;
11210finally {
11211 restoreStackSize(stackSize);
11212}
11213
11214rule__StringTypeScope__TypeAssignment_1
11215 @init {
11216 int stackSize = keepStackSize();
11217 }
11218:
11219 (
11220 { before(grammarAccess.getStringTypeScopeAccess().getTypeStringReferenceParserRuleCall_1_0()); }
11221 ruleStringReference
11222 { after(grammarAccess.getStringTypeScopeAccess().getTypeStringReferenceParserRuleCall_1_0()); }
11223 )
11224;
11225finally {
11226 restoreStackSize(stackSize);
11227}
11228
11229rule__StringTypeScope__SetsNewAssignment_2_0
11230 @init {
11231 int stackSize = keepStackSize();
11232 }
11233:
11234 (
11235 { before(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11236 (
11237 { before(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11238 '+='
11239 { after(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11240 )
11241 { after(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); }
11242 )
11243;
11244finally {
11245 restoreStackSize(stackSize);
11246}
11247
11248rule__StringTypeScope__SetsSumAssignment_2_1
11249 @init {
11250 int stackSize = keepStackSize();
11251 }
11252:
11253 (
11254 { before(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11255 (
11256 { before(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11257 '='
11258 { after(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11259 )
11260 { after(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); }
11261 )
11262;
11263finally {
11264 restoreStackSize(stackSize);
11265}
11266
11267rule__StringTypeScope__NumberAssignment_3_0
11268 @init {
11269 int stackSize = keepStackSize();
11270 }
11271:
11272 (
11273 { before(grammarAccess.getStringTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); }
11274 ruleExactNumber
11275 { after(grammarAccess.getStringTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); }
11276 )
11277;
11278finally {
11279 restoreStackSize(stackSize);
11280}
11281
11282rule__StringTypeScope__NumberAssignment_3_1
11283 @init {
11284 int stackSize = keepStackSize();
11285 }
11286:
11287 (
11288 { before(grammarAccess.getStringTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); }
11289 ruleIntervallNumber
11290 { after(grammarAccess.getStringTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); }
11291 )
11292;
11293finally {
11294 restoreStackSize(stackSize);
11295}
11296
11297rule__StringTypeScope__NumberAssignment_3_2
11298 @init {
11299 int stackSize = keepStackSize();
11300 }
11301:
11302 (
11303 { before(grammarAccess.getStringTypeScopeAccess().getNumberStringEnumerationParserRuleCall_3_2_0()); }
11304 ruleStringEnumeration
11305 { after(grammarAccess.getStringTypeScopeAccess().getNumberStringEnumerationParserRuleCall_3_2_0()); }
11306 )
11307;
11308finally {
11309 restoreStackSize(stackSize);
11310}
11311
11312rule__ClassReference__ElementAssignment_1
11313 @init {
11314 int stackSize = keepStackSize();
11315 }
11316:
11317 (
11318 { before(grammarAccess.getClassReferenceAccess().getElementMetamodelElementParserRuleCall_1_0()); }
11319 ruleMetamodelElement
11320 { after(grammarAccess.getClassReferenceAccess().getElementMetamodelElementParserRuleCall_1_0()); }
11321 )
11322;
11323finally {
11324 restoreStackSize(stackSize);
11325}
11326
11327rule__ExactNumber__ExactNumberAssignment_0
11328 @init {
11329 int stackSize = keepStackSize();
11330 }
11331:
11332 (
11333 { before(grammarAccess.getExactNumberAccess().getExactNumberINTTerminalRuleCall_0_0()); }
11334 RULE_INT
11335 { after(grammarAccess.getExactNumberAccess().getExactNumberINTTerminalRuleCall_0_0()); }
11336 )
11337;
11338finally {
11339 restoreStackSize(stackSize);
11340}
11341
11342rule__ExactNumber__ExactUnlimitedAssignment_1
11343 @init {
11344 int stackSize = keepStackSize();
11345 }
11346:
11347 (
11348 { before(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); }
11349 (
11350 { before(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); }
11351 '*'
11352 { after(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); }
11353 )
11354 { after(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); }
11355 )
11356;
11357finally {
11358 restoreStackSize(stackSize);
11359}
11360
11361rule__IntervallNumber__MinAssignment_0
11362 @init {
11363 int stackSize = keepStackSize();
11364 }
11365:
11366 (
11367 { before(grammarAccess.getIntervallNumberAccess().getMinINTTerminalRuleCall_0_0()); }
11368 RULE_INT
11369 { after(grammarAccess.getIntervallNumberAccess().getMinINTTerminalRuleCall_0_0()); }
11370 )
11371;
11372finally {
11373 restoreStackSize(stackSize);
11374}
11375
11376rule__IntervallNumber__MaxNumberAssignment_2_0
11377 @init {
11378 int stackSize = keepStackSize();
11379 }
11380:
11381 (
11382 { before(grammarAccess.getIntervallNumberAccess().getMaxNumberINTTerminalRuleCall_2_0_0()); }
11383 RULE_INT
11384 { after(grammarAccess.getIntervallNumberAccess().getMaxNumberINTTerminalRuleCall_2_0_0()); }
11385 )
11386;
11387finally {
11388 restoreStackSize(stackSize);
11389}
11390
11391rule__IntervallNumber__MaxUnlimitedAssignment_2_1
11392 @init {
11393 int stackSize = keepStackSize();
11394 }
11395:
11396 (
11397 { before(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); }
11398 (
11399 { before(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); }
11400 '*'
11401 { after(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); }
11402 )
11403 { after(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); }
11404 )
11405;
11406finally {
11407 restoreStackSize(stackSize);
11408}
11409
11410rule__IntEnumberation__EntryAssignment_2_0
11411 @init {
11412 int stackSize = keepStackSize();
11413 }
11414:
11415 (
11416 { before(grammarAccess.getIntEnumberationAccess().getEntryINTLiteralParserRuleCall_2_0_0()); }
11417 ruleINTLiteral
11418 { after(grammarAccess.getIntEnumberationAccess().getEntryINTLiteralParserRuleCall_2_0_0()); }
11419 )
11420;
11421finally {
11422 restoreStackSize(stackSize);
11423}
11424
11425rule__IntEnumberation__EntryAssignment_2_1_1
11426 @init {
11427 int stackSize = keepStackSize();
11428 }
11429:
11430 (
11431 { before(grammarAccess.getIntEnumberationAccess().getEntryINTLiteralParserRuleCall_2_1_1_0()); }
11432 ruleINTLiteral
11433 { after(grammarAccess.getIntEnumberationAccess().getEntryINTLiteralParserRuleCall_2_1_1_0()); }
11434 )
11435;
11436finally {
11437 restoreStackSize(stackSize);
11438}
11439
11440rule__RealEnumeration__EntryAssignment_2_0
11441 @init {
11442 int stackSize = keepStackSize();
11443 }
11444:
11445 (
11446 { before(grammarAccess.getRealEnumerationAccess().getEntryREALLiteralParserRuleCall_2_0_0()); }
11447 ruleREALLiteral
11448 { after(grammarAccess.getRealEnumerationAccess().getEntryREALLiteralParserRuleCall_2_0_0()); }
11449 )
11450;
11451finally {
11452 restoreStackSize(stackSize);
11453}
11454
11455rule__RealEnumeration__EntryAssignment_2_1_1
11456 @init {
11457 int stackSize = keepStackSize();
11458 }
11459:
11460 (
11461 { before(grammarAccess.getRealEnumerationAccess().getEntryREALLiteralParserRuleCall_2_1_1_0()); }
11462 ruleREALLiteral
11463 { after(grammarAccess.getRealEnumerationAccess().getEntryREALLiteralParserRuleCall_2_1_1_0()); }
11464 )
11465;
11466finally {
11467 restoreStackSize(stackSize);
11468}
11469
11470rule__StringEnumeration__EntryAssignment_2_0
11471 @init {
11472 int stackSize = keepStackSize();
11473 }
11474:
11475 (
11476 { before(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_0_0()); }
11477 RULE_STRING
11478 { after(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_0_0()); }
11479 )
11480;
11481finally {
11482 restoreStackSize(stackSize);
11483}
11484
11485rule__StringEnumeration__EntryAssignment_2_1_1
11486 @init {
11487 int stackSize = keepStackSize();
11488 }
11489:
11490 (
11491 { before(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_1_1_0()); }
11492 RULE_STRING
11493 { after(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_1_1_0()); }
11494 )
11495;
11496finally {
11497 restoreStackSize(stackSize);
11498}
11499
11500rule__ScopeDeclaration__NameAssignment_1
11501 @init {
11502 int stackSize = keepStackSize();
11503 }
11504:
11505 (
11506 { before(grammarAccess.getScopeDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
11507 RULE_ID
11508 { after(grammarAccess.getScopeDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
11509 )
11510;
11511finally {
11512 restoreStackSize(stackSize);
11513}
11514
11515rule__ScopeDeclaration__SpecificationAssignment_2
11516 @init {
11517 int stackSize = keepStackSize();
11518 }
11519:
11520 (
11521 { before(grammarAccess.getScopeDeclarationAccess().getSpecificationScopeSpecificationParserRuleCall_2_0()); }
11522 ruleScopeSpecification
11523 { after(grammarAccess.getScopeDeclarationAccess().getSpecificationScopeSpecificationParserRuleCall_2_0()); }
11524 )
11525;
11526finally {
11527 restoreStackSize(stackSize);
11528}
11529
11530rule__ScopeReference__ReferredAssignment
11531 @init {
11532 int stackSize = keepStackSize();
11533 }
11534:
11535 (
11536 { before(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationCrossReference_0()); }
11537 (
11538 { before(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationIDTerminalRuleCall_0_1()); }
11539 RULE_ID
11540 { after(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationIDTerminalRuleCall_0_1()); }
11541 )
11542 { after(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationCrossReference_0()); }
11543 )
11544;
11545finally {
11546 restoreStackSize(stackSize);
11547}
11548
11549rule__GenerationTask__MetamodelAssignment_3_0_2
11550 @init {
11551 int stackSize = keepStackSize();
11552 }
11553:
11554 (
11555 { before(grammarAccess.getGenerationTaskAccess().getMetamodelMetamodelParserRuleCall_3_0_2_0()); }
11556 ruleMetamodel
11557 { after(grammarAccess.getGenerationTaskAccess().getMetamodelMetamodelParserRuleCall_3_0_2_0()); }
11558 )
11559;
11560finally {
11561 restoreStackSize(stackSize);
11562}
11563
11564rule__GenerationTask__PartialModelAssignment_3_1_2
11565 @init {
11566 int stackSize = keepStackSize();
11567 }
11568:
11569 (
11570 { before(grammarAccess.getGenerationTaskAccess().getPartialModelPartialModelParserRuleCall_3_1_2_0()); }
11571 rulePartialModel
11572 { after(grammarAccess.getGenerationTaskAccess().getPartialModelPartialModelParserRuleCall_3_1_2_0()); }
11573 )
11574;
11575finally {
11576 restoreStackSize(stackSize);
11577}
11578
11579rule__GenerationTask__PatternsAssignment_3_2_2
11580 @init {
11581 int stackSize = keepStackSize();
11582 }
11583:
11584 (
11585 { before(grammarAccess.getGenerationTaskAccess().getPatternsGraphPatternParserRuleCall_3_2_2_0()); }
11586 ruleGraphPattern
11587 { after(grammarAccess.getGenerationTaskAccess().getPatternsGraphPatternParserRuleCall_3_2_2_0()); }
11588 )
11589;
11590finally {
11591 restoreStackSize(stackSize);
11592}
11593
11594rule__GenerationTask__ObjectivesAssignment_3_3_2
11595 @init {
11596 int stackSize = keepStackSize();
11597 }
11598:
11599 (
11600 { before(grammarAccess.getGenerationTaskAccess().getObjectivesObjectiveParserRuleCall_3_3_2_0()); }
11601 ruleObjective
11602 { after(grammarAccess.getGenerationTaskAccess().getObjectivesObjectiveParserRuleCall_3_3_2_0()); }
11603 )
11604;
11605finally {
11606 restoreStackSize(stackSize);
11607}
11608
11609rule__GenerationTask__ScopeAssignment_3_4_2
11610 @init {
11611 int stackSize = keepStackSize();
11612 }
11613:
11614 (
11615 { before(grammarAccess.getGenerationTaskAccess().getScopeScopeParserRuleCall_3_4_2_0()); }
11616 ruleScope
11617 { after(grammarAccess.getGenerationTaskAccess().getScopeScopeParserRuleCall_3_4_2_0()); }
11618 )
11619;
11620finally {
11621 restoreStackSize(stackSize);
11622}
11623
11624rule__GenerationTask__NumberSpecifiedAssignment_3_5_0
11625 @init {
11626 int stackSize = keepStackSize();
11627 }
11628:
11629 (
11630 { before(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_5_0_0()); }
11631 (
11632 { before(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_5_0_0()); }
11633 'number'
11634 { after(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_5_0_0()); }
11635 )
11636 { after(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_5_0_0()); }
11637 )
11638;
11639finally {
11640 restoreStackSize(stackSize);
11641}
11642
11643rule__GenerationTask__NumberAssignment_3_5_2
11644 @init {
11645 int stackSize = keepStackSize();
11646 }
11647:
11648 (
11649 { before(grammarAccess.getGenerationTaskAccess().getNumberINTTerminalRuleCall_3_5_2_0()); }
11650 RULE_INT
11651 { after(grammarAccess.getGenerationTaskAccess().getNumberINTTerminalRuleCall_3_5_2_0()); }
11652 )
11653;
11654finally {
11655 restoreStackSize(stackSize);
11656}
11657
11658rule__GenerationTask__RunSpecifiedAssignment_3_6_0
11659 @init {
11660 int stackSize = keepStackSize();
11661 }
11662:
11663 (
11664 { before(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_6_0_0()); }
11665 (
11666 { before(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_6_0_0()); }
11667 'runs'
11668 { after(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_6_0_0()); }
11669 )
11670 { after(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_6_0_0()); }
11671 )
11672;
11673finally {
11674 restoreStackSize(stackSize);
11675}
11676
11677rule__GenerationTask__RunsAssignment_3_6_2
11678 @init {
11679 int stackSize = keepStackSize();
11680 }
11681:
11682 (
11683 { before(grammarAccess.getGenerationTaskAccess().getRunsINTTerminalRuleCall_3_6_2_0()); }
11684 RULE_INT
11685 { after(grammarAccess.getGenerationTaskAccess().getRunsINTTerminalRuleCall_3_6_2_0()); }
11686 )
11687;
11688finally {
11689 restoreStackSize(stackSize);
11690}
11691
11692rule__GenerationTask__SolverAssignment_3_7_2
11693 @init {
11694 int stackSize = keepStackSize();
11695 }
11696:
11697 (
11698 { before(grammarAccess.getGenerationTaskAccess().getSolverSolverEnumRuleCall_3_7_2_0()); }
11699 ruleSolver
11700 { after(grammarAccess.getGenerationTaskAccess().getSolverSolverEnumRuleCall_3_7_2_0()); }
11701 )
11702;
11703finally {
11704 restoreStackSize(stackSize);
11705}
11706
11707rule__GenerationTask__ConfigAssignment_3_8_2
11708 @init {
11709 int stackSize = keepStackSize();
11710 }
11711:
11712 (
11713 { before(grammarAccess.getGenerationTaskAccess().getConfigConfigParserRuleCall_3_8_2_0()); }
11714 ruleConfig
11715 { after(grammarAccess.getGenerationTaskAccess().getConfigConfigParserRuleCall_3_8_2_0()); }
11716 )
11717;
11718finally {
11719 restoreStackSize(stackSize);
11720}
11721
11722rule__GenerationTask__DebugFolderAssignment_3_9_2
11723 @init {
11724 int stackSize = keepStackSize();
11725 }
11726:
11727 (
11728 { before(grammarAccess.getGenerationTaskAccess().getDebugFolderFileParserRuleCall_3_9_2_0()); }
11729 ruleFile
11730 { after(grammarAccess.getGenerationTaskAccess().getDebugFolderFileParserRuleCall_3_9_2_0()); }
11731 )
11732;
11733finally {
11734 restoreStackSize(stackSize);
11735}
11736
11737rule__GenerationTask__TargetLogFileAssignment_3_10_2
11738 @init {
11739 int stackSize = keepStackSize();
11740 }
11741:
11742 (
11743 { before(grammarAccess.getGenerationTaskAccess().getTargetLogFileFileParserRuleCall_3_10_2_0()); }
11744 ruleFile
11745 { after(grammarAccess.getGenerationTaskAccess().getTargetLogFileFileParserRuleCall_3_10_2_0()); }
11746 )
11747;
11748finally {
11749 restoreStackSize(stackSize);
11750}
11751
11752rule__GenerationTask__TargetStatisticsFileAssignment_3_11_2
11753 @init {
11754 int stackSize = keepStackSize();
11755 }
11756:
11757 (
11758 { before(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileFileParserRuleCall_3_11_2_0()); }
11759 ruleFile
11760 { after(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileFileParserRuleCall_3_11_2_0()); }
11761 )
11762;
11763finally {
11764 restoreStackSize(stackSize);
11765}
11766
11767rule__GenerationTask__TagetFolderAssignment_3_12_2
11768 @init {
11769 int stackSize = keepStackSize();
11770 }
11771:
11772 (
11773 { before(grammarAccess.getGenerationTaskAccess().getTagetFolderFileParserRuleCall_3_12_2_0()); }
11774 ruleFile
11775 { after(grammarAccess.getGenerationTaskAccess().getTagetFolderFileParserRuleCall_3_12_2_0()); }
11776 )
11777;
11778finally {
11779 restoreStackSize(stackSize);
11780}
11781
11782RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
11783
11784RULE_INT : ('0'..'9')+;
11785
11786RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\'');
11787
11788RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
11789
11790RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
11791
11792RULE_WS : (' '|'\t'|'\r'|'\n')+;
11793
11794RULE_ANY_OTHER : .;
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-08 05:01:12 +0000