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