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