aboutsummaryrefslogtreecommitdiffstats
path: root/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.g
diff options
context:
space:
mode:
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.g')
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.g5780
1 files changed, 3702 insertions, 2078 deletions
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.g b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.g
index a56b7fe0..107d9b8a 100644
--- a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.g
+++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.g
@@ -45,16 +45,19 @@ import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
45 tokenNameToValue.put("LessThanSign", "'<'"); 45 tokenNameToValue.put("LessThanSign", "'<'");
46 tokenNameToValue.put("EqualsSign", "'='"); 46 tokenNameToValue.put("EqualsSign", "'='");
47 tokenNameToValue.put("GreaterThanSign", "'>'"); 47 tokenNameToValue.put("GreaterThanSign", "'>'");
48 tokenNameToValue.put("QuestionMark", "'?'");
48 tokenNameToValue.put("LeftSquareBracket", "'['"); 49 tokenNameToValue.put("LeftSquareBracket", "'['");
49 tokenNameToValue.put("RightSquareBracket", "']'"); 50 tokenNameToValue.put("RightSquareBracket", "']'");
50 tokenNameToValue.put("CircumflexAccent", "'^'"); 51 tokenNameToValue.put("CircumflexAccent", "'^'");
51 tokenNameToValue.put("LeftCurlyBracket", "'{'"); 52 tokenNameToValue.put("LeftCurlyBracket", "'{'");
52 tokenNameToValue.put("VerticalLine", "'|'"); 53 tokenNameToValue.put("VerticalLine", "'|'");
53 tokenNameToValue.put("RightCurlyBracket", "'}'"); 54 tokenNameToValue.put("RightCurlyBracket", "'}'");
55 tokenNameToValue.put("Tilde", "'~'");
54 tokenNameToValue.put("ExclamationMarkEqualsSign", "'!='"); 56 tokenNameToValue.put("ExclamationMarkEqualsSign", "'!='");
55 tokenNameToValue.put("HyphenMinusGreaterThanSign", "'->'"); 57 tokenNameToValue.put("HyphenMinusGreaterThanSign", "'->'");
56 tokenNameToValue.put("FullStopFullStop", "'..'");
57 tokenNameToValue.put("ColonHyphenMinus", "':-'"); 58 tokenNameToValue.put("ColonHyphenMinus", "':-'");
59 tokenNameToValue.put("ColonColon", "'::'");
60 tokenNameToValue.put("ColonEqualsSign", "':='");
58 tokenNameToValue.put("LessThanSignEqualsSign", "'<='"); 61 tokenNameToValue.put("LessThanSignEqualsSign", "'<='");
59 tokenNameToValue.put("EqualsSignEqualsSign", "'=='"); 62 tokenNameToValue.put("EqualsSignEqualsSign", "'=='");
60 tokenNameToValue.put("EqualsSignGreaterThanSign", "'=>'"); 63 tokenNameToValue.put("EqualsSignGreaterThanSign", "'=>'");
@@ -65,9 +68,9 @@ import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
65 tokenNameToValue.put("FullStopFullStopFullStop", "'...'"); 68 tokenNameToValue.put("FullStopFullStopFullStop", "'...'");
66 tokenNameToValue.put("Inf", "'inf'"); 69 tokenNameToValue.put("Inf", "'inf'");
67 tokenNameToValue.put("Let", "'let'"); 70 tokenNameToValue.put("Let", "'let'");
68 tokenNameToValue.put("May", "'may'");
69 tokenNameToValue.put("Else", "'else'"); 71 tokenNameToValue.put("Else", "'else'");
70 tokenNameToValue.put("Must", "'must'"); 72 tokenNameToValue.put("Enum", "'enum'");
73 tokenNameToValue.put("Root", "'root'");
71 tokenNameToValue.put("Then", "'then'"); 74 tokenNameToValue.put("Then", "'then'");
72 tokenNameToValue.put("True", "'true'"); 75 tokenNameToValue.put("True", "'true'");
73 tokenNameToValue.put("Class", "'class'"); 76 tokenNameToValue.put("Class", "'class'");
@@ -76,12 +79,13 @@ import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
76 tokenNameToValue.put("Error", "'error'"); 79 tokenNameToValue.put("Error", "'error'");
77 tokenNameToValue.put("False", "'false'"); 80 tokenNameToValue.put("False", "'false'");
78 tokenNameToValue.put("Scope", "'scope'"); 81 tokenNameToValue.put("Scope", "'scope'");
79 tokenNameToValue.put("Exists", "'exists'");
80 tokenNameToValue.put("Extern", "'extern'"); 82 tokenNameToValue.put("Extern", "'extern'");
81 tokenNameToValue.put("Forall", "'forall'"); 83 tokenNameToValue.put("Import", "'import'");
82 tokenNameToValue.put("Current", "'current'"); 84 tokenNameToValue.put("Object", "'object'");
85 tokenNameToValue.put("Refers", "'refers'");
83 tokenNameToValue.put("Default", "'default'"); 86 tokenNameToValue.put("Default", "'default'");
84 tokenNameToValue.put("Extends", "'extends'"); 87 tokenNameToValue.put("Extends", "'extends'");
88 tokenNameToValue.put("Problem", "'problem'");
85 tokenNameToValue.put("Unknown", "'unknown'"); 89 tokenNameToValue.put("Unknown", "'unknown'");
86 tokenNameToValue.put("Abstract", "'abstract'"); 90 tokenNameToValue.put("Abstract", "'abstract'");
87 tokenNameToValue.put("Contains", "'contains'"); 91 tokenNameToValue.put("Contains", "'contains'");
@@ -90,6 +94,7 @@ import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
90 tokenNameToValue.put("Minimize", "'minimize'"); 94 tokenNameToValue.put("Minimize", "'minimize'");
91 tokenNameToValue.put("Opposite", "'opposite'"); 95 tokenNameToValue.put("Opposite", "'opposite'");
92 tokenNameToValue.put("Functional", "'functional'"); 96 tokenNameToValue.put("Functional", "'functional'");
97 tokenNameToValue.put("Containment", "'containment'");
93 } 98 }
94 99
95 public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) { 100 public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) {
@@ -126,9 +131,9 @@ ruleProblem
126 } 131 }
127 : 132 :
128 ( 133 (
129 { before(grammarAccess.getProblemAccess().getStatementsAssignment()); } 134 { before(grammarAccess.getProblemAccess().getGroup()); }
130 (rule__Problem__StatementsAssignment)* 135 (rule__Problem__Group__0)
131 { after(grammarAccess.getProblemAccess().getStatementsAssignment()); } 136 { after(grammarAccess.getProblemAccess().getGroup()); }
132 ) 137 )
133; 138;
134finally { 139finally {
@@ -151,9 +156,84 @@ ruleStatement
151 } 156 }
152 : 157 :
153 ( 158 (
154 { before(grammarAccess.getStatementAccess().getGroup()); } 159 { before(grammarAccess.getStatementAccess().getAlternatives()); }
155 (rule__Statement__Group__0) 160 (rule__Statement__Alternatives)
156 { after(grammarAccess.getStatementAccess().getGroup()); } 161 { after(grammarAccess.getStatementAccess().getAlternatives()); }
162 )
163;
164finally {
165 restoreStackSize(stackSize);
166}
167
168// Entry rule entryRuleImport
169entryRuleImport
170:
171{ before(grammarAccess.getImportRule()); }
172 ruleImport
173{ after(grammarAccess.getImportRule()); }
174 EOF
175;
176
177// Rule Import
178ruleImport
179 @init {
180 int stackSize = keepStackSize();
181 }
182 :
183 (
184 { before(grammarAccess.getImportAccess().getAlternatives()); }
185 (rule__Import__Alternatives)
186 { after(grammarAccess.getImportAccess().getAlternatives()); }
187 )
188;
189finally {
190 restoreStackSize(stackSize);
191}
192
193// Entry rule entryRuleUriImport
194entryRuleUriImport
195:
196{ before(grammarAccess.getUriImportRule()); }
197 ruleUriImport
198{ after(grammarAccess.getUriImportRule()); }
199 EOF
200;
201
202// Rule UriImport
203ruleUriImport
204 @init {
205 int stackSize = keepStackSize();
206 }
207 :
208 (
209 { before(grammarAccess.getUriImportAccess().getGroup()); }
210 (rule__UriImport__Group__0)
211 { after(grammarAccess.getUriImportAccess().getGroup()); }
212 )
213;
214finally {
215 restoreStackSize(stackSize);
216}
217
218// Entry rule entryRuleNamespaceImport
219entryRuleNamespaceImport
220:
221{ before(grammarAccess.getNamespaceImportRule()); }
222 ruleNamespaceImport
223{ after(grammarAccess.getNamespaceImportRule()); }
224 EOF
225;
226
227// Rule NamespaceImport
228ruleNamespaceImport
229 @init {
230 int stackSize = keepStackSize();
231 }
232 :
233 (
234 { before(grammarAccess.getNamespaceImportAccess().getGroup()); }
235 (rule__NamespaceImport__Group__0)
236 { after(grammarAccess.getNamespaceImportAccess().getGroup()); }
157 ) 237 )
158; 238;
159finally { 239finally {
@@ -210,200 +290,250 @@ finally {
210 restoreStackSize(stackSize); 290 restoreStackSize(stackSize);
211} 291}
212 292
213// Entry rule entryRuleUnnamedErrorPrediateDefinition 293// Entry rule entryRuleUnnamedErrorPredicateDefintion
214entryRuleUnnamedErrorPrediateDefinition 294entryRuleUnnamedErrorPredicateDefintion
295:
296{ before(grammarAccess.getUnnamedErrorPredicateDefintionRule()); }
297 ruleUnnamedErrorPredicateDefintion
298{ after(grammarAccess.getUnnamedErrorPredicateDefintionRule()); }
299 EOF
300;
301
302// Rule UnnamedErrorPredicateDefintion
303ruleUnnamedErrorPredicateDefintion
304 @init {
305 int stackSize = keepStackSize();
306 }
307 :
308 (
309 { before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getGroup()); }
310 (rule__UnnamedErrorPredicateDefintion__Group__0)
311 { after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getGroup()); }
312 )
313;
314finally {
315 restoreStackSize(stackSize);
316}
317
318// Entry rule entryRuleDefaultAssertion
319entryRuleDefaultAssertion
320:
321{ before(grammarAccess.getDefaultAssertionRule()); }
322 ruleDefaultAssertion
323{ after(grammarAccess.getDefaultAssertionRule()); }
324 EOF
325;
326
327// Rule DefaultAssertion
328ruleDefaultAssertion
329 @init {
330 int stackSize = keepStackSize();
331 }
332 :
333 (
334 { before(grammarAccess.getDefaultAssertionAccess().getGroup()); }
335 (rule__DefaultAssertion__Group__0)
336 { after(grammarAccess.getDefaultAssertionAccess().getGroup()); }
337 )
338;
339finally {
340 restoreStackSize(stackSize);
341}
342
343// Entry rule entryRuleFunctionDefinition
344entryRuleFunctionDefinition
215: 345:
216{ before(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); } 346{ before(grammarAccess.getFunctionDefinitionRule()); }
217 ruleUnnamedErrorPrediateDefinition 347 ruleFunctionDefinition
218{ after(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); } 348{ after(grammarAccess.getFunctionDefinitionRule()); }
219 EOF 349 EOF
220; 350;
221 351
222// Rule UnnamedErrorPrediateDefinition 352// Rule FunctionDefinition
223ruleUnnamedErrorPrediateDefinition 353ruleFunctionDefinition
224 @init { 354 @init {
225 int stackSize = keepStackSize(); 355 int stackSize = keepStackSize();
226 } 356 }
227 : 357 :
228 ( 358 (
229 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); } 359 { before(grammarAccess.getFunctionDefinitionAccess().getGroup()); }
230 (rule__UnnamedErrorPrediateDefinition__Group__0) 360 (rule__FunctionDefinition__Group__0)
231 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); } 361 { after(grammarAccess.getFunctionDefinitionAccess().getGroup()); }
232 ) 362 )
233; 363;
234finally { 364finally {
235 restoreStackSize(stackSize); 365 restoreStackSize(stackSize);
236} 366}
237 367
238// Entry rule entryRuleDefaultDefinition 368// Entry rule entryRuleTypeReference
239entryRuleDefaultDefinition 369entryRuleTypeReference
240: 370:
241{ before(grammarAccess.getDefaultDefinitionRule()); } 371{ before(grammarAccess.getTypeReferenceRule()); }
242 ruleDefaultDefinition 372 ruleTypeReference
243{ after(grammarAccess.getDefaultDefinitionRule()); } 373{ after(grammarAccess.getTypeReferenceRule()); }
244 EOF 374 EOF
245; 375;
246 376
247// Rule DefaultDefinition 377// Rule TypeReference
248ruleDefaultDefinition 378ruleTypeReference
249 @init { 379 @init {
250 int stackSize = keepStackSize(); 380 int stackSize = keepStackSize();
251 } 381 }
252 : 382 :
253 ( 383 (
254 { before(grammarAccess.getDefaultDefinitionAccess().getGroup()); } 384 { before(grammarAccess.getTypeReferenceAccess().getGroup()); }
255 (rule__DefaultDefinition__Group__0) 385 (rule__TypeReference__Group__0)
256 { after(grammarAccess.getDefaultDefinitionAccess().getGroup()); } 386 { after(grammarAccess.getTypeReferenceAccess().getGroup()); }
257 ) 387 )
258; 388;
259finally { 389finally {
260 restoreStackSize(stackSize); 390 restoreStackSize(stackSize);
261} 391}
262 392
263// Entry rule entryRuleMetricDefinition 393// Entry rule entryRuleAttribute
264entryRuleMetricDefinition 394entryRuleAttribute
265: 395:
266{ before(grammarAccess.getMetricDefinitionRule()); } 396{ before(grammarAccess.getAttributeRule()); }
267 ruleMetricDefinition 397 ruleAttribute
268{ after(grammarAccess.getMetricDefinitionRule()); } 398{ after(grammarAccess.getAttributeRule()); }
269 EOF 399 EOF
270; 400;
271 401
272// Rule MetricDefinition 402// Rule Attribute
273ruleMetricDefinition 403ruleAttribute
274 @init { 404 @init {
275 int stackSize = keepStackSize(); 405 int stackSize = keepStackSize();
276 } 406 }
277 : 407 :
278 ( 408 (
279 { before(grammarAccess.getMetricDefinitionAccess().getGroup()); } 409 { before(grammarAccess.getAttributeAccess().getGroup()); }
280 (rule__MetricDefinition__Group__0) 410 (rule__Attribute__Group__0)
281 { after(grammarAccess.getMetricDefinitionAccess().getGroup()); } 411 { after(grammarAccess.getAttributeAccess().getGroup()); }
282 ) 412 )
283; 413;
284finally { 414finally {
285 restoreStackSize(stackSize); 415 restoreStackSize(stackSize);
286} 416}
287 417
288// Entry rule entryRuleExternPredicateDefinition 418// Entry rule entryRuleExternDeclaration
289entryRuleExternPredicateDefinition 419entryRuleExternDeclaration
290: 420:
291{ before(grammarAccess.getExternPredicateDefinitionRule()); } 421{ before(grammarAccess.getExternDeclarationRule()); }
292 ruleExternPredicateDefinition 422 ruleExternDeclaration
293{ after(grammarAccess.getExternPredicateDefinitionRule()); } 423{ after(grammarAccess.getExternDeclarationRule()); }
294 EOF 424 EOF
295; 425;
296 426
297// Rule ExternPredicateDefinition 427// Rule ExternDeclaration
298ruleExternPredicateDefinition 428ruleExternDeclaration
299 @init { 429 @init {
300 int stackSize = keepStackSize(); 430 int stackSize = keepStackSize();
301 } 431 }
302 : 432 :
303 ( 433 (
304 { before(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); } 434 { before(grammarAccess.getExternDeclarationAccess().getAlternatives()); }
305 (rule__ExternPredicateDefinition__Group__0) 435 (rule__ExternDeclaration__Alternatives)
306 { after(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); } 436 { after(grammarAccess.getExternDeclarationAccess().getAlternatives()); }
307 ) 437 )
308; 438;
309finally { 439finally {
310 restoreStackSize(stackSize); 440 restoreStackSize(stackSize);
311} 441}
312 442
313// Entry rule entryRuleExternMetricDefinition 443// Entry rule entryRuleExternPredicateDeclaration
314entryRuleExternMetricDefinition 444entryRuleExternPredicateDeclaration
315: 445:
316{ before(grammarAccess.getExternMetricDefinitionRule()); } 446{ before(grammarAccess.getExternPredicateDeclarationRule()); }
317 ruleExternMetricDefinition 447 ruleExternPredicateDeclaration
318{ after(grammarAccess.getExternMetricDefinitionRule()); } 448{ after(grammarAccess.getExternPredicateDeclarationRule()); }
319 EOF 449 EOF
320; 450;
321 451
322// Rule ExternMetricDefinition 452// Rule ExternPredicateDeclaration
323ruleExternMetricDefinition 453ruleExternPredicateDeclaration
324 @init { 454 @init {
325 int stackSize = keepStackSize(); 455 int stackSize = keepStackSize();
326 } 456 }
327 : 457 :
328 ( 458 (
329 { before(grammarAccess.getExternMetricDefinitionAccess().getGroup()); } 459 { before(grammarAccess.getExternPredicateDeclarationAccess().getGroup()); }
330 (rule__ExternMetricDefinition__Group__0) 460 (rule__ExternPredicateDeclaration__Group__0)
331 { after(grammarAccess.getExternMetricDefinitionAccess().getGroup()); } 461 { after(grammarAccess.getExternPredicateDeclarationAccess().getGroup()); }
332 ) 462 )
333; 463;
334finally { 464finally {
335 restoreStackSize(stackSize); 465 restoreStackSize(stackSize);
336} 466}
337 467
338// Entry rule entryRuleExternAggregatorDefinition 468// Entry rule entryRuleExternFunctionDeclaration
339entryRuleExternAggregatorDefinition 469entryRuleExternFunctionDeclaration
340: 470:
341{ before(grammarAccess.getExternAggregatorDefinitionRule()); } 471{ before(grammarAccess.getExternFunctionDeclarationRule()); }
342 ruleExternAggregatorDefinition 472 ruleExternFunctionDeclaration
343{ after(grammarAccess.getExternAggregatorDefinitionRule()); } 473{ after(grammarAccess.getExternFunctionDeclarationRule()); }
344 EOF 474 EOF
345; 475;
346 476
347// Rule ExternAggregatorDefinition 477// Rule ExternFunctionDeclaration
348ruleExternAggregatorDefinition 478ruleExternFunctionDeclaration
349 @init { 479 @init {
350 int stackSize = keepStackSize(); 480 int stackSize = keepStackSize();
351 } 481 }
352 : 482 :
353 ( 483 (
354 { before(grammarAccess.getExternAggregatorDefinitionAccess().getGroup()); } 484 { before(grammarAccess.getExternFunctionDeclarationAccess().getGroup()); }
355 (rule__ExternAggregatorDefinition__Group__0) 485 (rule__ExternFunctionDeclaration__Group__0)
356 { after(grammarAccess.getExternAggregatorDefinitionAccess().getGroup()); } 486 { after(grammarAccess.getExternFunctionDeclarationAccess().getGroup()); }
357 ) 487 )
358; 488;
359finally { 489finally {
360 restoreStackSize(stackSize); 490 restoreStackSize(stackSize);
361} 491}
362 492
363// Entry rule entryRuleExternDatatypeDefinition 493// Entry rule entryRuleExternAggregationOperatorDeclaration
364entryRuleExternDatatypeDefinition 494entryRuleExternAggregationOperatorDeclaration
365: 495:
366{ before(grammarAccess.getExternDatatypeDefinitionRule()); } 496{ before(grammarAccess.getExternAggregationOperatorDeclarationRule()); }
367 ruleExternDatatypeDefinition 497 ruleExternAggregationOperatorDeclaration
368{ after(grammarAccess.getExternDatatypeDefinitionRule()); } 498{ after(grammarAccess.getExternAggregationOperatorDeclarationRule()); }
369 EOF 499 EOF
370; 500;
371 501
372// Rule ExternDatatypeDefinition 502// Rule ExternAggregationOperatorDeclaration
373ruleExternDatatypeDefinition 503ruleExternAggregationOperatorDeclaration
374 @init { 504 @init {
375 int stackSize = keepStackSize(); 505 int stackSize = keepStackSize();
376 } 506 }
377 : 507 :
378 ( 508 (
379 { before(grammarAccess.getExternDatatypeDefinitionAccess().getGroup()); } 509 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getGroup()); }
380 (rule__ExternDatatypeDefinition__Group__0) 510 (rule__ExternAggregationOperatorDeclaration__Group__0)
381 { after(grammarAccess.getExternDatatypeDefinitionAccess().getGroup()); } 511 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getGroup()); }
382 ) 512 )
383; 513;
384finally { 514finally {
385 restoreStackSize(stackSize); 515 restoreStackSize(stackSize);
386} 516}
387 517
388// Entry rule entryRuleVariable 518// Entry rule entryRuleExternDatatypeDeclaration
389entryRuleVariable 519entryRuleExternDatatypeDeclaration
390: 520:
391{ before(grammarAccess.getVariableRule()); } 521{ before(grammarAccess.getExternDatatypeDeclarationRule()); }
392 ruleVariable 522 ruleExternDatatypeDeclaration
393{ after(grammarAccess.getVariableRule()); } 523{ after(grammarAccess.getExternDatatypeDeclarationRule()); }
394 EOF 524 EOF
395; 525;
396 526
397// Rule Variable 527// Rule ExternDatatypeDeclaration
398ruleVariable 528ruleExternDatatypeDeclaration
399 @init { 529 @init {
400 int stackSize = keepStackSize(); 530 int stackSize = keepStackSize();
401 } 531 }
402 : 532 :
403 ( 533 (
404 { before(grammarAccess.getVariableAccess().getGroup()); } 534 { before(grammarAccess.getExternDatatypeDeclarationAccess().getGroup()); }
405 (rule__Variable__Group__0) 535 (rule__ExternDatatypeDeclaration__Group__0)
406 { after(grammarAccess.getVariableAccess().getGroup()); } 536 { after(grammarAccess.getExternDatatypeDeclarationAccess().getGroup()); }
407 ) 537 )
408; 538;
409finally { 539finally {
@@ -435,50 +565,50 @@ finally {
435 restoreStackSize(stackSize); 565 restoreStackSize(stackSize);
436} 566}
437 567
438// Entry rule entryRuleIfElse 568// Entry rule entryRuleConditionalExpression
439entryRuleIfElse 569entryRuleConditionalExpression
440: 570:
441{ before(grammarAccess.getIfElseRule()); } 571{ before(grammarAccess.getConditionalExpressionRule()); }
442 ruleIfElse 572 ruleConditionalExpression
443{ after(grammarAccess.getIfElseRule()); } 573{ after(grammarAccess.getConditionalExpressionRule()); }
444 EOF 574 EOF
445; 575;
446 576
447// Rule IfElse 577// Rule ConditionalExpression
448ruleIfElse 578ruleConditionalExpression
449 @init { 579 @init {
450 int stackSize = keepStackSize(); 580 int stackSize = keepStackSize();
451 } 581 }
452 : 582 :
453 ( 583 (
454 { before(grammarAccess.getIfElseAccess().getGroup()); } 584 { before(grammarAccess.getConditionalExpressionAccess().getGroup()); }
455 (rule__IfElse__Group__0) 585 (rule__ConditionalExpression__Group__0)
456 { after(grammarAccess.getIfElseAccess().getGroup()); } 586 { after(grammarAccess.getConditionalExpressionAccess().getGroup()); }
457 ) 587 )
458; 588;
459finally { 589finally {
460 restoreStackSize(stackSize); 590 restoreStackSize(stackSize);
461} 591}
462 592
463// Entry rule entryRuleLet 593// Entry rule entryRuleLetExpression
464entryRuleLet 594entryRuleLetExpression
465: 595:
466{ before(grammarAccess.getLetRule()); } 596{ before(grammarAccess.getLetExpressionRule()); }
467 ruleLet 597 ruleLetExpression
468{ after(grammarAccess.getLetRule()); } 598{ after(grammarAccess.getLetExpressionRule()); }
469 EOF 599 EOF
470; 600;
471 601
472// Rule Let 602// Rule LetExpression
473ruleLet 603ruleLetExpression
474 @init { 604 @init {
475 int stackSize = keepStackSize(); 605 int stackSize = keepStackSize();
476 } 606 }
477 : 607 :
478 ( 608 (
479 { before(grammarAccess.getLetAccess().getGroup()); } 609 { before(grammarAccess.getLetExpressionAccess().getGroup()); }
480 (rule__Let__Group__0) 610 (rule__LetExpression__Group__0)
481 { after(grammarAccess.getLetAccess().getGroup()); } 611 { after(grammarAccess.getLetExpressionAccess().getGroup()); }
482 ) 612 )
483; 613;
484finally { 614finally {
@@ -510,31 +640,6 @@ finally {
510 restoreStackSize(stackSize); 640 restoreStackSize(stackSize);
511} 641}
512 642
513// Entry rule entryRuleImplicationExpression
514entryRuleImplicationExpression
515:
516{ before(grammarAccess.getImplicationExpressionRule()); }
517 ruleImplicationExpression
518{ after(grammarAccess.getImplicationExpressionRule()); }
519 EOF
520;
521
522// Rule ImplicationExpression
523ruleImplicationExpression
524 @init {
525 int stackSize = keepStackSize();
526 }
527 :
528 (
529 { before(grammarAccess.getImplicationExpressionAccess().getGroup()); }
530 (rule__ImplicationExpression__Group__0)
531 { after(grammarAccess.getImplicationExpressionAccess().getGroup()); }
532 )
533;
534finally {
535 restoreStackSize(stackSize);
536}
537
538// Entry rule entryRuleDisjunctiveExpression 643// Entry rule entryRuleDisjunctiveExpression
539entryRuleDisjunctiveExpression 644entryRuleDisjunctiveExpression
540: 645:
@@ -760,100 +865,75 @@ finally {
760 restoreStackSize(stackSize); 865 restoreStackSize(stackSize);
761} 866}
762 867
763// Entry rule entryRuleAggregationExpression 868// Entry rule entryRuleBracedAggregateExpression
764entryRuleAggregationExpression 869entryRuleBracedAggregateExpression
765:
766{ before(grammarAccess.getAggregationExpressionRule()); }
767 ruleAggregationExpression
768{ after(grammarAccess.getAggregationExpressionRule()); }
769 EOF
770;
771
772// Rule AggregationExpression
773ruleAggregationExpression
774 @init {
775 int stackSize = keepStackSize();
776 }
777 :
778 (
779 { before(grammarAccess.getAggregationExpressionAccess().getAlternatives()); }
780 (rule__AggregationExpression__Alternatives)
781 { after(grammarAccess.getAggregationExpressionAccess().getAlternatives()); }
782 )
783;
784finally {
785 restoreStackSize(stackSize);
786}
787
788// Entry rule entryRuleLocalVariables
789entryRuleLocalVariables
790: 870:
791{ before(grammarAccess.getLocalVariablesRule()); } 871{ before(grammarAccess.getBracedAggregateExpressionRule()); }
792 ruleLocalVariables 872 ruleBracedAggregateExpression
793{ after(grammarAccess.getLocalVariablesRule()); } 873{ after(grammarAccess.getBracedAggregateExpressionRule()); }
794 EOF 874 EOF
795; 875;
796 876
797// Rule LocalVariables 877// Rule BracedAggregateExpression
798ruleLocalVariables 878ruleBracedAggregateExpression
799 @init { 879 @init {
800 int stackSize = keepStackSize(); 880 int stackSize = keepStackSize();
801 } 881 }
802 : 882 :
803 ( 883 (
804 { before(grammarAccess.getLocalVariablesAccess().getGroup()); } 884 { before(grammarAccess.getBracedAggregateExpressionAccess().getAlternatives()); }
805 (rule__LocalVariables__Group__0) 885 (rule__BracedAggregateExpression__Alternatives)
806 { after(grammarAccess.getLocalVariablesAccess().getGroup()); } 886 { after(grammarAccess.getBracedAggregateExpressionAccess().getAlternatives()); }
807 ) 887 )
808; 888;
809finally { 889finally {
810 restoreStackSize(stackSize); 890 restoreStackSize(stackSize);
811} 891}
812 892
813// Entry rule entryRuleQuantifiedExpression 893// Entry rule entryRuleAggregation
814entryRuleQuantifiedExpression 894entryRuleAggregation
815: 895:
816{ before(grammarAccess.getQuantifiedExpressionRule()); } 896{ before(grammarAccess.getAggregationRule()); }
817 ruleQuantifiedExpression 897 ruleAggregation
818{ after(grammarAccess.getQuantifiedExpressionRule()); } 898{ after(grammarAccess.getAggregationRule()); }
819 EOF 899 EOF
820; 900;
821 901
822// Rule QuantifiedExpression 902// Rule Aggregation
823ruleQuantifiedExpression 903ruleAggregation
824 @init { 904 @init {
825 int stackSize = keepStackSize(); 905 int stackSize = keepStackSize();
826 } 906 }
827 : 907 :
828 ( 908 (
829 { before(grammarAccess.getQuantifiedExpressionAccess().getGroup()); } 909 { before(grammarAccess.getAggregationAccess().getGroup()); }
830 (rule__QuantifiedExpression__Group__0) 910 (rule__Aggregation__Group__0)
831 { after(grammarAccess.getQuantifiedExpressionAccess().getGroup()); } 911 { after(grammarAccess.getAggregationAccess().getGroup()); }
832 ) 912 )
833; 913;
834finally { 914finally {
835 restoreStackSize(stackSize); 915 restoreStackSize(stackSize);
836} 916}
837 917
838// Entry rule entryRuleAggregation 918// Entry rule entryRuleCount
839entryRuleAggregation 919entryRuleCount
840: 920:
841{ before(grammarAccess.getAggregationRule()); } 921{ before(grammarAccess.getCountRule()); }
842 ruleAggregation 922 ruleCount
843{ after(grammarAccess.getAggregationRule()); } 923{ after(grammarAccess.getCountRule()); }
844 EOF 924 EOF
845; 925;
846 926
847// Rule Aggregation 927// Rule Count
848ruleAggregation 928ruleCount
849 @init { 929 @init {
850 int stackSize = keepStackSize(); 930 int stackSize = keepStackSize();
851 } 931 }
852 : 932 :
853 ( 933 (
854 { before(grammarAccess.getAggregationAccess().getGroup()); } 934 { before(grammarAccess.getCountAccess().getGroup()); }
855 (rule__Aggregation__Group__0) 935 (rule__Count__Group__0)
856 { after(grammarAccess.getAggregationAccess().getGroup()); } 936 { after(grammarAccess.getCountAccess().getGroup()); }
857 ) 937 )
858; 938;
859finally { 939finally {
@@ -976,9 +1056,9 @@ ruleExpressionArgument
976 } 1056 }
977 : 1057 :
978 ( 1058 (
979 { before(grammarAccess.getExpressionArgumentAccess().getBodyAssignment()); } 1059 { before(grammarAccess.getExpressionArgumentAccess().getExpressionAssignment()); }
980 (rule__ExpressionArgument__BodyAssignment) 1060 (rule__ExpressionArgument__ExpressionAssignment)
981 { after(grammarAccess.getExpressionArgumentAccess().getBodyAssignment()); } 1061 { after(grammarAccess.getExpressionArgumentAccess().getExpressionAssignment()); }
982 ) 1062 )
983; 1063;
984finally { 1064finally {
@@ -1010,25 +1090,25 @@ finally {
1010 restoreStackSize(stackSize); 1090 restoreStackSize(stackSize);
1011} 1091}
1012 1092
1013// Entry rule entryRuleTypedArgument 1093// Entry rule entryRuleTypedVariableArgument
1014entryRuleTypedArgument 1094entryRuleTypedVariableArgument
1015: 1095:
1016{ before(grammarAccess.getTypedArgumentRule()); } 1096{ before(grammarAccess.getTypedVariableArgumentRule()); }
1017 ruleTypedArgument 1097 ruleTypedVariableArgument
1018{ after(grammarAccess.getTypedArgumentRule()); } 1098{ after(grammarAccess.getTypedVariableArgumentRule()); }
1019 EOF 1099 EOF
1020; 1100;
1021 1101
1022// Rule TypedArgument 1102// Rule TypedVariableArgument
1023ruleTypedArgument 1103ruleTypedVariableArgument
1024 @init { 1104 @init {
1025 int stackSize = keepStackSize(); 1105 int stackSize = keepStackSize();
1026 } 1106 }
1027 : 1107 :
1028 ( 1108 (
1029 { before(grammarAccess.getTypedArgumentAccess().getGroup()); } 1109 { before(grammarAccess.getTypedVariableArgumentAccess().getGroup()); }
1030 (rule__TypedArgument__Group__0) 1110 (rule__TypedVariableArgument__Group__0)
1031 { after(grammarAccess.getTypedArgumentAccess().getGroup()); } 1111 { after(grammarAccess.getTypedVariableArgumentAccess().getGroup()); }
1032 ) 1112 )
1033; 1113;
1034finally { 1114finally {
@@ -1076,9 +1156,34 @@ ruleReference
1076 } 1156 }
1077 : 1157 :
1078 ( 1158 (
1079 { before(grammarAccess.getReferenceAccess().getReferredAssignment()); } 1159 { before(grammarAccess.getReferenceAccess().getGroup()); }
1080 (rule__Reference__ReferredAssignment) 1160 (rule__Reference__Group__0)
1081 { after(grammarAccess.getReferenceAccess().getReferredAssignment()); } 1161 { after(grammarAccess.getReferenceAccess().getGroup()); }
1162 )
1163;
1164finally {
1165 restoreStackSize(stackSize);
1166}
1167
1168// Entry rule entryRulePathComponent
1169entryRulePathComponent
1170:
1171{ before(grammarAccess.getPathComponentRule()); }
1172 rulePathComponent
1173{ after(grammarAccess.getPathComponentRule()); }
1174 EOF
1175;
1176
1177// Rule PathComponent
1178rulePathComponent
1179 @init {
1180 int stackSize = keepStackSize();
1181 }
1182 :
1183 (
1184 { before(grammarAccess.getPathComponentAccess().getGroup()); }
1185 (rule__PathComponent__Group__0)
1186 { after(grammarAccess.getPathComponentAccess().getGroup()); }
1082 ) 1187 )
1083; 1188;
1084finally { 1189finally {
@@ -1160,25 +1265,50 @@ finally {
1160 restoreStackSize(stackSize); 1265 restoreStackSize(stackSize);
1161} 1266}
1162 1267
1163// Entry rule entryRuleNumericLiteral 1268// Entry rule entryRuleIntLiteral
1164entryRuleNumericLiteral 1269entryRuleIntLiteral
1270:
1271{ before(grammarAccess.getIntLiteralRule()); }
1272 ruleIntLiteral
1273{ after(grammarAccess.getIntLiteralRule()); }
1274 EOF
1275;
1276
1277// Rule IntLiteral
1278ruleIntLiteral
1279 @init {
1280 int stackSize = keepStackSize();
1281 }
1282 :
1283 (
1284 { before(grammarAccess.getIntLiteralAccess().getValueAssignment()); }
1285 (rule__IntLiteral__ValueAssignment)
1286 { after(grammarAccess.getIntLiteralAccess().getValueAssignment()); }
1287 )
1288;
1289finally {
1290 restoreStackSize(stackSize);
1291}
1292
1293// Entry rule entryRuleRealLiteral
1294entryRuleRealLiteral
1165: 1295:
1166{ before(grammarAccess.getNumericLiteralRule()); } 1296{ before(grammarAccess.getRealLiteralRule()); }
1167 ruleNumericLiteral 1297 ruleRealLiteral
1168{ after(grammarAccess.getNumericLiteralRule()); } 1298{ after(grammarAccess.getRealLiteralRule()); }
1169 EOF 1299 EOF
1170; 1300;
1171 1301
1172// Rule NumericLiteral 1302// Rule RealLiteral
1173ruleNumericLiteral 1303ruleRealLiteral
1174 @init { 1304 @init {
1175 int stackSize = keepStackSize(); 1305 int stackSize = keepStackSize();
1176 } 1306 }
1177 : 1307 :
1178 ( 1308 (
1179 { before(grammarAccess.getNumericLiteralAccess().getValueAssignment()); } 1309 { before(grammarAccess.getRealLiteralAccess().getValueAssignment()); }
1180 (rule__NumericLiteral__ValueAssignment) 1310 (rule__RealLiteral__ValueAssignment)
1181 { after(grammarAccess.getNumericLiteralAccess().getValueAssignment()); } 1311 { after(grammarAccess.getRealLiteralAccess().getValueAssignment()); }
1182 ) 1312 )
1183; 1313;
1184finally { 1314finally {
@@ -1210,25 +1340,25 @@ finally {
1210 restoreStackSize(stackSize); 1340 restoreStackSize(stackSize);
1211} 1341}
1212 1342
1213// Entry rule entryRuleEmptyIntervalLiteral 1343// Entry rule entryRuleEmptyLiteral
1214entryRuleEmptyIntervalLiteral 1344entryRuleEmptyLiteral
1215: 1345:
1216{ before(grammarAccess.getEmptyIntervalLiteralRule()); } 1346{ before(grammarAccess.getEmptyLiteralRule()); }
1217 ruleEmptyIntervalLiteral 1347 ruleEmptyLiteral
1218{ after(grammarAccess.getEmptyIntervalLiteralRule()); } 1348{ after(grammarAccess.getEmptyLiteralRule()); }
1219 EOF 1349 EOF
1220; 1350;
1221 1351
1222// Rule EmptyIntervalLiteral 1352// Rule EmptyLiteral
1223ruleEmptyIntervalLiteral 1353ruleEmptyLiteral
1224 @init { 1354 @init {
1225 int stackSize = keepStackSize(); 1355 int stackSize = keepStackSize();
1226 } 1356 }
1227 : 1357 :
1228 ( 1358 (
1229 { before(grammarAccess.getEmptyIntervalLiteralAccess().getGroup()); } 1359 { before(grammarAccess.getEmptyLiteralAccess().getGroup()); }
1230 (rule__EmptyIntervalLiteral__Group__0) 1360 (rule__EmptyLiteral__Group__0)
1231 { after(grammarAccess.getEmptyIntervalLiteralAccess().getGroup()); } 1361 { after(grammarAccess.getEmptyLiteralAccess().getGroup()); }
1232 ) 1362 )
1233; 1363;
1234finally { 1364finally {
@@ -1260,50 +1390,50 @@ finally {
1260 restoreStackSize(stackSize); 1390 restoreStackSize(stackSize);
1261} 1391}
1262 1392
1263// Entry rule entryRuleClassDefinition 1393// Entry rule entryRuleClassDeclaration
1264entryRuleClassDefinition 1394entryRuleClassDeclaration
1265: 1395:
1266{ before(grammarAccess.getClassDefinitionRule()); } 1396{ before(grammarAccess.getClassDeclarationRule()); }
1267 ruleClassDefinition 1397 ruleClassDeclaration
1268{ after(grammarAccess.getClassDefinitionRule()); } 1398{ after(grammarAccess.getClassDeclarationRule()); }
1269 EOF 1399 EOF
1270; 1400;
1271 1401
1272// Rule ClassDefinition 1402// Rule ClassDeclaration
1273ruleClassDefinition 1403ruleClassDeclaration
1274 @init { 1404 @init {
1275 int stackSize = keepStackSize(); 1405 int stackSize = keepStackSize();
1276 } 1406 }
1277 : 1407 :
1278 ( 1408 (
1279 { before(grammarAccess.getClassDefinitionAccess().getGroup()); } 1409 { before(grammarAccess.getClassDeclarationAccess().getGroup()); }
1280 (rule__ClassDefinition__Group__0) 1410 (rule__ClassDeclaration__Group__0)
1281 { after(grammarAccess.getClassDefinitionAccess().getGroup()); } 1411 { after(grammarAccess.getClassDeclarationAccess().getGroup()); }
1282 ) 1412 )
1283; 1413;
1284finally { 1414finally {
1285 restoreStackSize(stackSize); 1415 restoreStackSize(stackSize);
1286} 1416}
1287 1417
1288// Entry rule entryRuleMemberDefinition 1418// Entry rule entryRuleField
1289entryRuleMemberDefinition 1419entryRuleField
1290: 1420:
1291{ before(grammarAccess.getMemberDefinitionRule()); } 1421{ before(grammarAccess.getFieldRule()); }
1292 ruleMemberDefinition 1422 ruleField
1293{ after(grammarAccess.getMemberDefinitionRule()); } 1423{ after(grammarAccess.getFieldRule()); }
1294 EOF 1424 EOF
1295; 1425;
1296 1426
1297// Rule MemberDefinition 1427// Rule Field
1298ruleMemberDefinition 1428ruleField
1299 @init { 1429 @init {
1300 int stackSize = keepStackSize(); 1430 int stackSize = keepStackSize();
1301 } 1431 }
1302 : 1432 :
1303 ( 1433 (
1304 { before(grammarAccess.getMemberDefinitionAccess().getGroup()); } 1434 { before(grammarAccess.getFieldAccess().getGroup()); }
1305 (rule__MemberDefinition__Group__0) 1435 (rule__Field__Group__0)
1306 { after(grammarAccess.getMemberDefinitionAccess().getGroup()); } 1436 { after(grammarAccess.getFieldAccess().getGroup()); }
1307 ) 1437 )
1308; 1438;
1309finally { 1439finally {
@@ -1335,25 +1465,25 @@ finally {
1335 restoreStackSize(stackSize); 1465 restoreStackSize(stackSize);
1336} 1466}
1337 1467
1338// Entry rule entryRuleManyMultiplicity 1468// Entry rule entryRuleUnboundedMultiplicity
1339entryRuleManyMultiplicity 1469entryRuleUnboundedMultiplicity
1340: 1470:
1341{ before(grammarAccess.getManyMultiplicityRule()); } 1471{ before(grammarAccess.getUnboundedMultiplicityRule()); }
1342 ruleManyMultiplicity 1472 ruleUnboundedMultiplicity
1343{ after(grammarAccess.getManyMultiplicityRule()); } 1473{ after(grammarAccess.getUnboundedMultiplicityRule()); }
1344 EOF 1474 EOF
1345; 1475;
1346 1476
1347// Rule ManyMultiplicity 1477// Rule UnboundedMultiplicity
1348ruleManyMultiplicity 1478ruleUnboundedMultiplicity
1349 @init { 1479 @init {
1350 int stackSize = keepStackSize(); 1480 int stackSize = keepStackSize();
1351 } 1481 }
1352 : 1482 :
1353 ( 1483 (
1354 { before(grammarAccess.getManyMultiplicityAccess().getGroup()); } 1484 { before(grammarAccess.getUnboundedMultiplicityAccess().getGroup()); }
1355 (rule__ManyMultiplicity__Group__0) 1485 (rule__UnboundedMultiplicity__Group__0)
1356 { after(grammarAccess.getManyMultiplicityAccess().getGroup()); } 1486 { after(grammarAccess.getUnboundedMultiplicityAccess().getGroup()); }
1357 ) 1487 )
1358; 1488;
1359finally { 1489finally {
@@ -1410,125 +1540,175 @@ finally {
1410 restoreStackSize(stackSize); 1540 restoreStackSize(stackSize);
1411} 1541}
1412 1542
1413// Entry rule entryRuleScopeDefinition 1543// Entry rule entryRuleEnumDeclaration
1414entryRuleScopeDefinition 1544entryRuleEnumDeclaration
1545:
1546{ before(grammarAccess.getEnumDeclarationRule()); }
1547 ruleEnumDeclaration
1548{ after(grammarAccess.getEnumDeclarationRule()); }
1549 EOF
1550;
1551
1552// Rule EnumDeclaration
1553ruleEnumDeclaration
1554 @init {
1555 int stackSize = keepStackSize();
1556 }
1557 :
1558 (
1559 { before(grammarAccess.getEnumDeclarationAccess().getGroup()); }
1560 (rule__EnumDeclaration__Group__0)
1561 { after(grammarAccess.getEnumDeclarationAccess().getGroup()); }
1562 )
1563;
1564finally {
1565 restoreStackSize(stackSize);
1566}
1567
1568// Entry rule entryRuleEnumLiteral
1569entryRuleEnumLiteral
1570:
1571{ before(grammarAccess.getEnumLiteralRule()); }
1572 ruleEnumLiteral
1573{ after(grammarAccess.getEnumLiteralRule()); }
1574 EOF
1575;
1576
1577// Rule EnumLiteral
1578ruleEnumLiteral
1579 @init {
1580 int stackSize = keepStackSize();
1581 }
1582 :
1583 (
1584 { before(grammarAccess.getEnumLiteralAccess().getNameAssignment()); }
1585 (rule__EnumLiteral__NameAssignment)
1586 { after(grammarAccess.getEnumLiteralAccess().getNameAssignment()); }
1587 )
1588;
1589finally {
1590 restoreStackSize(stackSize);
1591}
1592
1593// Entry rule entryRuleScopeDeclaration
1594entryRuleScopeDeclaration
1415: 1595:
1416{ before(grammarAccess.getScopeDefinitionRule()); } 1596{ before(grammarAccess.getScopeDeclarationRule()); }
1417 ruleScopeDefinition 1597 ruleScopeDeclaration
1418{ after(grammarAccess.getScopeDefinitionRule()); } 1598{ after(grammarAccess.getScopeDeclarationRule()); }
1419 EOF 1599 EOF
1420; 1600;
1421 1601
1422// Rule ScopeDefinition 1602// Rule ScopeDeclaration
1423ruleScopeDefinition 1603ruleScopeDeclaration
1424 @init { 1604 @init {
1425 int stackSize = keepStackSize(); 1605 int stackSize = keepStackSize();
1426 } 1606 }
1427 : 1607 :
1428 ( 1608 (
1429 { before(grammarAccess.getScopeDefinitionAccess().getAlternatives()); } 1609 { before(grammarAccess.getScopeDeclarationAccess().getAlternatives()); }
1430 (rule__ScopeDefinition__Alternatives) 1610 (rule__ScopeDeclaration__Alternatives)
1431 { after(grammarAccess.getScopeDefinitionAccess().getAlternatives()); } 1611 { after(grammarAccess.getScopeDeclarationAccess().getAlternatives()); }
1432 ) 1612 )
1433; 1613;
1434finally { 1614finally {
1435 restoreStackSize(stackSize); 1615 restoreStackSize(stackSize);
1436} 1616}
1437 1617
1438// Entry rule entryRuleExactScopeDefinition 1618// Entry rule entryRuleExactScope
1439entryRuleExactScopeDefinition 1619entryRuleExactScope
1440: 1620:
1441{ before(grammarAccess.getExactScopeDefinitionRule()); } 1621{ before(grammarAccess.getExactScopeRule()); }
1442 ruleExactScopeDefinition 1622 ruleExactScope
1443{ after(grammarAccess.getExactScopeDefinitionRule()); } 1623{ after(grammarAccess.getExactScopeRule()); }
1444 EOF 1624 EOF
1445; 1625;
1446 1626
1447// Rule ExactScopeDefinition 1627// Rule ExactScope
1448ruleExactScopeDefinition 1628ruleExactScope
1449 @init { 1629 @init {
1450 int stackSize = keepStackSize(); 1630 int stackSize = keepStackSize();
1451 } 1631 }
1452 : 1632 :
1453 ( 1633 (
1454 { before(grammarAccess.getExactScopeDefinitionAccess().getGroup()); } 1634 { before(grammarAccess.getExactScopeAccess().getGroup()); }
1455 (rule__ExactScopeDefinition__Group__0) 1635 (rule__ExactScope__Group__0)
1456 { after(grammarAccess.getExactScopeDefinitionAccess().getGroup()); } 1636 { after(grammarAccess.getExactScopeAccess().getGroup()); }
1457 ) 1637 )
1458; 1638;
1459finally { 1639finally {
1460 restoreStackSize(stackSize); 1640 restoreStackSize(stackSize);
1461} 1641}
1462 1642
1463// Entry rule entryRuleBoundedScopeDefinition 1643// Entry rule entryRuleBoundedScope
1464entryRuleBoundedScopeDefinition 1644entryRuleBoundedScope
1465: 1645:
1466{ before(grammarAccess.getBoundedScopeDefinitionRule()); } 1646{ before(grammarAccess.getBoundedScopeRule()); }
1467 ruleBoundedScopeDefinition 1647 ruleBoundedScope
1468{ after(grammarAccess.getBoundedScopeDefinitionRule()); } 1648{ after(grammarAccess.getBoundedScopeRule()); }
1469 EOF 1649 EOF
1470; 1650;
1471 1651
1472// Rule BoundedScopeDefinition 1652// Rule BoundedScope
1473ruleBoundedScopeDefinition 1653ruleBoundedScope
1474 @init { 1654 @init {
1475 int stackSize = keepStackSize(); 1655 int stackSize = keepStackSize();
1476 } 1656 }
1477 : 1657 :
1478 ( 1658 (
1479 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); } 1659 { before(grammarAccess.getBoundedScopeAccess().getGroup()); }
1480 (rule__BoundedScopeDefinition__Group__0) 1660 (rule__BoundedScope__Group__0)
1481 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); } 1661 { after(grammarAccess.getBoundedScopeAccess().getGroup()); }
1482 ) 1662 )
1483; 1663;
1484finally { 1664finally {
1485 restoreStackSize(stackSize); 1665 restoreStackSize(stackSize);
1486} 1666}
1487 1667
1488// Entry rule entryRuleLowerBoundedScopeDefinition 1668// Entry rule entryRuleLowerBoundedScope
1489entryRuleLowerBoundedScopeDefinition 1669entryRuleLowerBoundedScope
1490: 1670:
1491{ before(grammarAccess.getLowerBoundedScopeDefinitionRule()); } 1671{ before(grammarAccess.getLowerBoundedScopeRule()); }
1492 ruleLowerBoundedScopeDefinition 1672 ruleLowerBoundedScope
1493{ after(grammarAccess.getLowerBoundedScopeDefinitionRule()); } 1673{ after(grammarAccess.getLowerBoundedScopeRule()); }
1494 EOF 1674 EOF
1495; 1675;
1496 1676
1497// Rule LowerBoundedScopeDefinition 1677// Rule LowerBoundedScope
1498ruleLowerBoundedScopeDefinition 1678ruleLowerBoundedScope
1499 @init { 1679 @init {
1500 int stackSize = keepStackSize(); 1680 int stackSize = keepStackSize();
1501 } 1681 }
1502 : 1682 :
1503 ( 1683 (
1504 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); } 1684 { before(grammarAccess.getLowerBoundedScopeAccess().getGroup()); }
1505 (rule__LowerBoundedScopeDefinition__Group__0) 1685 (rule__LowerBoundedScope__Group__0)
1506 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); } 1686 { after(grammarAccess.getLowerBoundedScopeAccess().getGroup()); }
1507 ) 1687 )
1508; 1688;
1509finally { 1689finally {
1510 restoreStackSize(stackSize); 1690 restoreStackSize(stackSize);
1511} 1691}
1512 1692
1513// Entry rule entryRuleObjectiveDefinition 1693// Entry rule entryRuleObjectiveDeclaration
1514entryRuleObjectiveDefinition 1694entryRuleObjectiveDeclaration
1515: 1695:
1516{ before(grammarAccess.getObjectiveDefinitionRule()); } 1696{ before(grammarAccess.getObjectiveDeclarationRule()); }
1517 ruleObjectiveDefinition 1697 ruleObjectiveDeclaration
1518{ after(grammarAccess.getObjectiveDefinitionRule()); } 1698{ after(grammarAccess.getObjectiveDeclarationRule()); }
1519 EOF 1699 EOF
1520; 1700;
1521 1701
1522// Rule ObjectiveDefinition 1702// Rule ObjectiveDeclaration
1523ruleObjectiveDefinition 1703ruleObjectiveDeclaration
1524 @init { 1704 @init {
1525 int stackSize = keepStackSize(); 1705 int stackSize = keepStackSize();
1526 } 1706 }
1527 : 1707 :
1528 ( 1708 (
1529 { before(grammarAccess.getObjectiveDefinitionAccess().getGroup()); } 1709 { before(grammarAccess.getObjectiveDeclarationAccess().getGroup()); }
1530 (rule__ObjectiveDefinition__Group__0) 1710 (rule__ObjectiveDeclaration__Group__0)
1531 { after(grammarAccess.getObjectiveDefinitionAccess().getGroup()); } 1711 { after(grammarAccess.getObjectiveDeclarationAccess().getGroup()); }
1532 ) 1712 )
1533; 1713;
1534finally { 1714finally {
@@ -1593,6 +1773,31 @@ finally {
1593 myHiddenTokenState.restore(); 1773 myHiddenTokenState.restore();
1594} 1774}
1595 1775
1776// Entry rule entryRuleQualifiedNameSegment
1777entryRuleQualifiedNameSegment
1778:
1779{ before(grammarAccess.getQualifiedNameSegmentRule()); }
1780 ruleQualifiedNameSegment
1781{ after(grammarAccess.getQualifiedNameSegmentRule()); }
1782 EOF
1783;
1784
1785// Rule QualifiedNameSegment
1786ruleQualifiedNameSegment
1787 @init {
1788 int stackSize = keepStackSize();
1789 }
1790 :
1791 (
1792 { before(grammarAccess.getQualifiedNameSegmentAccess().getAlternatives()); }
1793 (rule__QualifiedNameSegment__Alternatives)
1794 { after(grammarAccess.getQualifiedNameSegmentAccess().getAlternatives()); }
1795 )
1796;
1797finally {
1798 restoreStackSize(stackSize);
1799}
1800
1596// Entry rule entryRuleQualifiedName 1801// Entry rule entryRuleQualifiedName
1597entryRuleQualifiedName 1802entryRuleQualifiedName
1598@init { 1803@init {
@@ -1616,9 +1821,9 @@ ruleQualifiedName
1616 } 1821 }
1617 : 1822 :
1618 ( 1823 (
1619 { before(grammarAccess.getQualifiedNameAccess().getAlternatives()); } 1824 { before(grammarAccess.getQualifiedNameAccess().getGroup()); }
1620 (rule__QualifiedName__Alternatives) 1825 (rule__QualifiedName__Group__0)
1621 { after(grammarAccess.getQualifiedNameAccess().getAlternatives()); } 1826 { after(grammarAccess.getQualifiedNameAccess().getGroup()); }
1622 ) 1827 )
1623; 1828;
1624finally { 1829finally {
@@ -1626,16 +1831,16 @@ finally {
1626 myHiddenTokenState.restore(); 1831 myHiddenTokenState.restore();
1627} 1832}
1628 1833
1629// Rule ImplicationOperator 1834// Rule AttributeKind
1630ruleImplicationOperator 1835ruleAttributeKind
1631 @init { 1836 @init {
1632 int stackSize = keepStackSize(); 1837 int stackSize = keepStackSize();
1633 } 1838 }
1634: 1839:
1635 ( 1840 (
1636 { before(grammarAccess.getImplicationOperatorAccess().getIMPLIESEnumLiteralDeclaration()); } 1841 { before(grammarAccess.getAttributeKindAccess().getAlternatives()); }
1637 (EqualsSignGreaterThanSign) 1842 (rule__AttributeKind__Alternatives)
1638 { after(grammarAccess.getImplicationOperatorAccess().getIMPLIESEnumLiteralDeclaration()); } 1843 { after(grammarAccess.getAttributeKindAccess().getAlternatives()); }
1639 ) 1844 )
1640; 1845;
1641finally { 1846finally {
@@ -1706,32 +1911,16 @@ finally {
1706 restoreStackSize(stackSize); 1911 restoreStackSize(stackSize);
1707} 1912}
1708 1913
1709// Rule UnaryOp 1914// Rule UnaryOperator
1710ruleUnaryOp 1915ruleUnaryOperator
1711 @init {
1712 int stackSize = keepStackSize();
1713 }
1714:
1715 (
1716 { before(grammarAccess.getUnaryOpAccess().getAlternatives()); }
1717 (rule__UnaryOp__Alternatives)
1718 { after(grammarAccess.getUnaryOpAccess().getAlternatives()); }
1719 )
1720;
1721finally {
1722 restoreStackSize(stackSize);
1723}
1724
1725// Rule Quantifier
1726ruleQuantifier
1727 @init { 1916 @init {
1728 int stackSize = keepStackSize(); 1917 int stackSize = keepStackSize();
1729 } 1918 }
1730: 1919:
1731 ( 1920 (
1732 { before(grammarAccess.getQuantifierAccess().getAlternatives()); } 1921 { before(grammarAccess.getUnaryOperatorAccess().getAlternatives()); }
1733 (rule__Quantifier__Alternatives) 1922 (rule__UnaryOperator__Alternatives)
1734 { after(grammarAccess.getQuantifierAccess().getAlternatives()); } 1923 { after(grammarAccess.getUnaryOperatorAccess().getAlternatives()); }
1735 ) 1924 )
1736; 1925;
1737finally { 1926finally {
@@ -1770,81 +1959,96 @@ finally {
1770 restoreStackSize(stackSize); 1959 restoreStackSize(stackSize);
1771} 1960}
1772 1961
1773rule__Statement__Alternatives_0 1962rule__Statement__Alternatives
1774 @init { 1963 @init {
1775 int stackSize = keepStackSize(); 1964 int stackSize = keepStackSize();
1776 } 1965 }
1777: 1966:
1778 ( 1967 (
1779 { before(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); } 1968 { before(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0()); }
1780 ruleAssertionOrDefinition 1969 ruleAssertionOrDefinition
1781 { after(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); } 1970 { after(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0()); }
1782 ) 1971 )
1783 | 1972 |
1784 ( 1973 (
1785 { before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); } 1974 { before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_1()); }
1786 rulePredicateDefinition 1975 rulePredicateDefinition
1787 { after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); } 1976 { after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_1()); }
1788 ) 1977 )
1789 | 1978 |
1790 ( 1979 (
1791 { before(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); } 1980 { before(grammarAccess.getStatementAccess().getUnnamedErrorPredicateDefintionParserRuleCall_2()); }
1792 ruleUnnamedErrorPrediateDefinition 1981 ruleUnnamedErrorPredicateDefintion
1793 { after(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); } 1982 { after(grammarAccess.getStatementAccess().getUnnamedErrorPredicateDefintionParserRuleCall_2()); }
1794 ) 1983 )
1795 | 1984 |
1796 ( 1985 (
1797 { before(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); } 1986 { before(grammarAccess.getStatementAccess().getDefaultAssertionParserRuleCall_3()); }
1798 ruleDefaultDefinition 1987 ruleDefaultAssertion
1799 { after(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); } 1988 { after(grammarAccess.getStatementAccess().getDefaultAssertionParserRuleCall_3()); }
1800 ) 1989 )
1801 | 1990 |
1802 ( 1991 (
1803 { before(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_4()); } 1992 { before(grammarAccess.getStatementAccess().getFunctionDefinitionParserRuleCall_4()); }
1804 ruleMetricDefinition 1993 ruleFunctionDefinition
1805 { after(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_4()); } 1994 { after(grammarAccess.getStatementAccess().getFunctionDefinitionParserRuleCall_4()); }
1806 ) 1995 )
1807 | 1996 |
1808 ( 1997 (
1809 { before(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_5()); } 1998 { before(grammarAccess.getStatementAccess().getAttributeParserRuleCall_5()); }
1810 ruleExternPredicateDefinition 1999 ruleAttribute
1811 { after(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_5()); } 2000 { after(grammarAccess.getStatementAccess().getAttributeParserRuleCall_5()); }
1812 ) 2001 )
1813 | 2002 |
1814 ( 2003 (
1815 { before(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); } 2004 { before(grammarAccess.getStatementAccess().getExternDeclarationParserRuleCall_6()); }
1816 ruleExternMetricDefinition 2005 ruleExternDeclaration
1817 { after(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); } 2006 { after(grammarAccess.getStatementAccess().getExternDeclarationParserRuleCall_6()); }
1818 ) 2007 )
1819 | 2008 |
1820 ( 2009 (
1821 { before(grammarAccess.getStatementAccess().getExternAggregatorDefinitionParserRuleCall_0_7()); } 2010 { before(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_7()); }
1822 ruleExternAggregatorDefinition 2011 ruleScopeDeclaration
1823 { after(grammarAccess.getStatementAccess().getExternAggregatorDefinitionParserRuleCall_0_7()); } 2012 { after(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_7()); }
1824 ) 2013 )
1825 | 2014 |
1826 ( 2015 (
1827 { before(grammarAccess.getStatementAccess().getExternDatatypeDefinitionParserRuleCall_0_8()); } 2016 { before(grammarAccess.getStatementAccess().getObjectiveDeclarationParserRuleCall_8()); }
1828 ruleExternDatatypeDefinition 2017 ruleObjectiveDeclaration
1829 { after(grammarAccess.getStatementAccess().getExternDatatypeDefinitionParserRuleCall_0_8()); } 2018 { after(grammarAccess.getStatementAccess().getObjectiveDeclarationParserRuleCall_8()); }
1830 ) 2019 )
1831 | 2020 |
1832 ( 2021 (
1833 { before(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_9()); } 2022 { before(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_9()); }
1834 ruleClassDefinition 2023 ruleClassDeclaration
1835 { after(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_9()); } 2024 { after(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_9()); }
1836 ) 2025 )
1837 | 2026 |
1838 ( 2027 (
1839 { before(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_10()); } 2028 { before(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_10()); }
1840 ruleScopeDefinition 2029 ruleEnumDeclaration
1841 { after(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_10()); } 2030 { after(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_10()); }
2031 )
2032;
2033finally {
2034 restoreStackSize(stackSize);
2035}
2036
2037rule__Import__Alternatives
2038 @init {
2039 int stackSize = keepStackSize();
2040 }
2041:
2042 (
2043 { before(grammarAccess.getImportAccess().getUriImportParserRuleCall_0()); }
2044 ruleUriImport
2045 { after(grammarAccess.getImportAccess().getUriImportParserRuleCall_0()); }
1842 ) 2046 )
1843 | 2047 |
1844 ( 2048 (
1845 { before(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_11()); } 2049 { before(grammarAccess.getImportAccess().getNamespaceImportParserRuleCall_1()); }
1846 ruleObjectiveDefinition 2050 ruleNamespaceImport
1847 { after(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_11()); } 2051 { after(grammarAccess.getImportAccess().getNamespaceImportParserRuleCall_1()); }
1848 ) 2052 )
1849; 2053;
1850finally { 2054finally {
@@ -1899,27 +2103,60 @@ finally {
1899 restoreStackSize(stackSize); 2103 restoreStackSize(stackSize);
1900} 2104}
1901 2105
2106rule__ExternDeclaration__Alternatives
2107 @init {
2108 int stackSize = keepStackSize();
2109 }
2110:
2111 (
2112 { before(grammarAccess.getExternDeclarationAccess().getExternPredicateDeclarationParserRuleCall_0()); }
2113 ruleExternPredicateDeclaration
2114 { after(grammarAccess.getExternDeclarationAccess().getExternPredicateDeclarationParserRuleCall_0()); }
2115 )
2116 |
2117 (
2118 { before(grammarAccess.getExternDeclarationAccess().getExternFunctionDeclarationParserRuleCall_1()); }
2119 ruleExternFunctionDeclaration
2120 { after(grammarAccess.getExternDeclarationAccess().getExternFunctionDeclarationParserRuleCall_1()); }
2121 )
2122 |
2123 (
2124 { before(grammarAccess.getExternDeclarationAccess().getExternAggregationOperatorDeclarationParserRuleCall_2()); }
2125 ruleExternAggregationOperatorDeclaration
2126 { after(grammarAccess.getExternDeclarationAccess().getExternAggregationOperatorDeclarationParserRuleCall_2()); }
2127 )
2128 |
2129 (
2130 { before(grammarAccess.getExternDeclarationAccess().getExternDatatypeDeclarationParserRuleCall_3()); }
2131 ruleExternDatatypeDeclaration
2132 { after(grammarAccess.getExternDeclarationAccess().getExternDatatypeDeclarationParserRuleCall_3()); }
2133 )
2134;
2135finally {
2136 restoreStackSize(stackSize);
2137}
2138
1902rule__Expression__Alternatives 2139rule__Expression__Alternatives
1903 @init { 2140 @init {
1904 int stackSize = keepStackSize(); 2141 int stackSize = keepStackSize();
1905 } 2142 }
1906: 2143:
1907 ( 2144 (
1908 { before(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); } 2145 { before(grammarAccess.getExpressionAccess().getConditionalExpressionParserRuleCall_0()); }
1909 ruleIfElse 2146 ruleConditionalExpression
1910 { after(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); } 2147 { after(grammarAccess.getExpressionAccess().getConditionalExpressionParserRuleCall_0()); }
1911 ) 2148 )
1912 | 2149 |
1913 ( 2150 (
1914 { before(grammarAccess.getExpressionAccess().getLetParserRuleCall_1()); } 2151 { before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_1()); }
1915 ruleLet 2152 ruleLetExpression
1916 { after(grammarAccess.getExpressionAccess().getLetParserRuleCall_1()); } 2153 { after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_1()); }
1917 ) 2154 )
1918 | 2155 |
1919 ( 2156 (
1920 { before(grammarAccess.getExpressionAccess().getImplicationExpressionParserRuleCall_2()); } 2157 { before(grammarAccess.getExpressionAccess().getGroup_2()); }
1921 ruleImplicationExpression 2158 (rule__Expression__Group_2__0)
1922 { after(grammarAccess.getExpressionAccess().getImplicationExpressionParserRuleCall_2()); } 2159 { after(grammarAccess.getExpressionAccess().getGroup_2()); }
1923 ) 2160 )
1924; 2161;
1925finally { 2162finally {
@@ -1953,9 +2190,9 @@ rule__UnaryExpression__Alternatives
1953 } 2190 }
1954: 2191:
1955 ( 2192 (
1956 { before(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); } 2193 { before(grammarAccess.getUnaryExpressionAccess().getBracedAggregateExpressionParserRuleCall_0()); }
1957 ruleAggregationExpression 2194 ruleBracedAggregateExpression
1958 { after(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); } 2195 { after(grammarAccess.getUnaryExpressionAccess().getBracedAggregateExpressionParserRuleCall_0()); }
1959 ) 2196 )
1960 | 2197 |
1961 ( 2198 (
@@ -1968,27 +2205,27 @@ finally {
1968 restoreStackSize(stackSize); 2205 restoreStackSize(stackSize);
1969} 2206}
1970 2207
1971rule__AggregationExpression__Alternatives 2208rule__BracedAggregateExpression__Alternatives
1972 @init { 2209 @init {
1973 int stackSize = keepStackSize(); 2210 int stackSize = keepStackSize();
1974 } 2211 }
1975: 2212:
1976 ( 2213 (
1977 { before(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); } 2214 { before(grammarAccess.getBracedAggregateExpressionAccess().getAtomicExpressionParserRuleCall_0()); }
1978 ruleAtomicExpression 2215 ruleAtomicExpression
1979 { after(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); } 2216 { after(grammarAccess.getBracedAggregateExpressionAccess().getAtomicExpressionParserRuleCall_0()); }
1980 ) 2217 )
1981 | 2218 |
1982 ( 2219 (
1983 { before(grammarAccess.getAggregationExpressionAccess().getQuantifiedExpressionParserRuleCall_1()); } 2220 { before(grammarAccess.getBracedAggregateExpressionAccess().getAggregationParserRuleCall_1()); }
1984 ruleQuantifiedExpression 2221 ruleAggregation
1985 { after(grammarAccess.getAggregationExpressionAccess().getQuantifiedExpressionParserRuleCall_1()); } 2222 { after(grammarAccess.getBracedAggregateExpressionAccess().getAggregationParserRuleCall_1()); }
1986 ) 2223 )
1987 | 2224 |
1988 ( 2225 (
1989 { before(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); } 2226 { before(grammarAccess.getBracedAggregateExpressionAccess().getCountParserRuleCall_2()); }
1990 ruleAggregation 2227 ruleCount
1991 { after(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); } 2228 { after(grammarAccess.getBracedAggregateExpressionAccess().getCountParserRuleCall_2()); }
1992 ) 2229 )
1993; 2230;
1994finally { 2231finally {
@@ -2034,27 +2271,6 @@ finally {
2034 restoreStackSize(stackSize); 2271 restoreStackSize(stackSize);
2035} 2272}
2036 2273
2037rule__Call__Alternatives_1
2038 @init {
2039 int stackSize = keepStackSize();
2040 }
2041:
2042 (
2043 { before(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); }
2044 (rule__Call__TransitiveClosureAssignment_1_0)
2045 { after(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); }
2046 )
2047 |
2048 (
2049 { before(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); }
2050 (rule__Call__ReflexiveTransitiveClosureAssignment_1_1)
2051 { after(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); }
2052 )
2053;
2054finally {
2055 restoreStackSize(stackSize);
2056}
2057
2058rule__Argument__Alternatives 2274rule__Argument__Alternatives
2059 @init { 2275 @init {
2060 int stackSize = keepStackSize(); 2276 int stackSize = keepStackSize();
@@ -2073,9 +2289,9 @@ rule__Argument__Alternatives
2073 ) 2289 )
2074 | 2290 |
2075 ( 2291 (
2076 { before(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); } 2292 { before(grammarAccess.getArgumentAccess().getTypedVariableArgumentParserRuleCall_2()); }
2077 ruleTypedArgument 2293 ruleTypedVariableArgument
2078 { after(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); } 2294 { after(grammarAccess.getArgumentAccess().getTypedVariableArgumentParserRuleCall_2()); }
2079 ) 2295 )
2080 | 2296 |
2081 ( 2297 (
@@ -2088,6 +2304,27 @@ finally {
2088 restoreStackSize(stackSize); 2304 restoreStackSize(stackSize);
2089} 2305}
2090 2306
2307rule__PathComponent__Alternatives_2
2308 @init {
2309 int stackSize = keepStackSize();
2310 }
2311:
2312 (
2313 { before(grammarAccess.getPathComponentAccess().getTransitiveClosureAssignment_2_0()); }
2314 (rule__PathComponent__TransitiveClosureAssignment_2_0)
2315 { after(grammarAccess.getPathComponentAccess().getTransitiveClosureAssignment_2_0()); }
2316 )
2317 |
2318 (
2319 { before(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureAssignment_2_1()); }
2320 (rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1)
2321 { after(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureAssignment_2_1()); }
2322 )
2323;
2324finally {
2325 restoreStackSize(stackSize);
2326}
2327
2091rule__Literal__Alternatives 2328rule__Literal__Alternatives
2092 @init { 2329 @init {
2093 int stackSize = keepStackSize(); 2330 int stackSize = keepStackSize();
@@ -2100,27 +2337,75 @@ rule__Literal__Alternatives
2100 ) 2337 )
2101 | 2338 |
2102 ( 2339 (
2103 { before(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); } 2340 { before(grammarAccess.getLiteralAccess().getIntLiteralParserRuleCall_1()); }
2104 ruleNumericLiteral 2341 ruleIntLiteral
2105 { after(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); } 2342 { after(grammarAccess.getLiteralAccess().getIntLiteralParserRuleCall_1()); }
2343 )
2344 |
2345 (
2346 { before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_2()); }
2347 ruleRealLiteral
2348 { after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_2()); }
2106 ) 2349 )
2107 | 2350 |
2108 ( 2351 (
2109 { before(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); } 2352 { before(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_3()); }
2110 ruleInfinityLiteral 2353 ruleInfinityLiteral
2111 { after(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); } 2354 { after(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_3()); }
2112 ) 2355 )
2113 | 2356 |
2114 ( 2357 (
2115 { before(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); } 2358 { before(grammarAccess.getLiteralAccess().getEmptyLiteralParserRuleCall_4()); }
2116 ruleEmptyIntervalLiteral 2359 ruleEmptyLiteral
2117 { after(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); } 2360 { after(grammarAccess.getLiteralAccess().getEmptyLiteralParserRuleCall_4()); }
2118 ) 2361 )
2119 | 2362 |
2120 ( 2363 (
2121 { before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } 2364 { before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_5()); }
2122 ruleStringLiteral 2365 ruleStringLiteral
2123 { after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } 2366 { after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_5()); }
2367 )
2368;
2369finally {
2370 restoreStackSize(stackSize);
2371}
2372
2373rule__ClassDeclaration__Alternatives_4
2374 @init {
2375 int stackSize = keepStackSize();
2376 }
2377:
2378 (
2379 { before(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); }
2380 (rule__ClassDeclaration__Group_4_0__0)
2381 { after(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); }
2382 )
2383 |
2384 (
2385 { before(grammarAccess.getClassDeclarationAccess().getFULL_STOPTerminalRuleCall_4_1()); }
2386 RULE_FULL_STOP
2387 { after(grammarAccess.getClassDeclarationAccess().getFULL_STOPTerminalRuleCall_4_1()); }
2388 )
2389;
2390finally {
2391 restoreStackSize(stackSize);
2392}
2393
2394rule__Field__Alternatives_0
2395 @init {
2396 int stackSize = keepStackSize();
2397 }
2398:
2399 (
2400 { before(grammarAccess.getFieldAccess().getContainmentAssignment_0_0()); }
2401 (rule__Field__ContainmentAssignment_0_0)
2402 { after(grammarAccess.getFieldAccess().getContainmentAssignment_0_0()); }
2403 )
2404 |
2405 (
2406 { before(grammarAccess.getFieldAccess().getCrossReferenceAssignment_0_1()); }
2407 (rule__Field__CrossReferenceAssignment_0_1)
2408 { after(grammarAccess.getFieldAccess().getCrossReferenceAssignment_0_1()); }
2124 ) 2409 )
2125; 2410;
2126finally { 2411finally {
@@ -2133,9 +2418,9 @@ rule__Multiplicity__Alternatives
2133 } 2418 }
2134: 2419:
2135 ( 2420 (
2136 { before(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); } 2421 { before(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); }
2137 ruleManyMultiplicity 2422 ruleUnboundedMultiplicity
2138 { after(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); } 2423 { after(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); }
2139 ) 2424 )
2140 | 2425 |
2141 ( 2426 (
@@ -2154,69 +2439,90 @@ finally {
2154 restoreStackSize(stackSize); 2439 restoreStackSize(stackSize);
2155} 2440}
2156 2441
2157rule__ScopeDefinition__Alternatives 2442rule__EnumDeclaration__Alternatives_2
2158 @init { 2443 @init {
2159 int stackSize = keepStackSize(); 2444 int stackSize = keepStackSize();
2160 } 2445 }
2161: 2446:
2162 ( 2447 (
2163 { before(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); } 2448 { before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); }
2164 ruleExactScopeDefinition 2449 (rule__EnumDeclaration__Group_2_0__0)
2165 { after(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); } 2450 { after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); }
2166 ) 2451 )
2167 | 2452 |
2168 ( 2453 (
2169 { before(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); } 2454 { before(grammarAccess.getEnumDeclarationAccess().getFULL_STOPTerminalRuleCall_2_1()); }
2170 ruleBoundedScopeDefinition 2455 RULE_FULL_STOP
2171 { after(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); } 2456 { after(grammarAccess.getEnumDeclarationAccess().getFULL_STOPTerminalRuleCall_2_1()); }
2457 )
2458;
2459finally {
2460 restoreStackSize(stackSize);
2461}
2462
2463rule__ScopeDeclaration__Alternatives
2464 @init {
2465 int stackSize = keepStackSize();
2466 }
2467:
2468 (
2469 { before(grammarAccess.getScopeDeclarationAccess().getExactScopeParserRuleCall_0()); }
2470 ruleExactScope
2471 { after(grammarAccess.getScopeDeclarationAccess().getExactScopeParserRuleCall_0()); }
2472 )
2473 |
2474 (
2475 { before(grammarAccess.getScopeDeclarationAccess().getBoundedScopeParserRuleCall_1()); }
2476 ruleBoundedScope
2477 { after(grammarAccess.getScopeDeclarationAccess().getBoundedScopeParserRuleCall_1()); }
2172 ) 2478 )
2173 | 2479 |
2174 ( 2480 (
2175 { before(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); } 2481 { before(grammarAccess.getScopeDeclarationAccess().getLowerBoundedScopeParserRuleCall_2()); }
2176 ruleLowerBoundedScopeDefinition 2482 ruleLowerBoundedScope
2177 { after(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); } 2483 { after(grammarAccess.getScopeDeclarationAccess().getLowerBoundedScopeParserRuleCall_2()); }
2178 ) 2484 )
2179; 2485;
2180finally { 2486finally {
2181 restoreStackSize(stackSize); 2487 restoreStackSize(stackSize);
2182} 2488}
2183 2489
2184rule__BoundedScopeDefinition__Alternatives_1 2490rule__BoundedScope__Alternatives_1
2185 @init { 2491 @init {
2186 int stackSize = keepStackSize(); 2492 int stackSize = keepStackSize();
2187 } 2493 }
2188: 2494:
2189 ( 2495 (
2190 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); } 2496 { before(grammarAccess.getBoundedScopeAccess().getGroup_1_0()); }
2191 (rule__BoundedScopeDefinition__Group_1_0__0) 2497 (rule__BoundedScope__Group_1_0__0)
2192 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); } 2498 { after(grammarAccess.getBoundedScopeAccess().getGroup_1_0()); }
2193 ) 2499 )
2194 | 2500 |
2195 ( 2501 (
2196 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); } 2502 { before(grammarAccess.getBoundedScopeAccess().getGroup_1_1()); }
2197 (rule__BoundedScopeDefinition__Group_1_1__0) 2503 (rule__BoundedScope__Group_1_1__0)
2198 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); } 2504 { after(grammarAccess.getBoundedScopeAccess().getGroup_1_1()); }
2199 ) 2505 )
2200; 2506;
2201finally { 2507finally {
2202 restoreStackSize(stackSize); 2508 restoreStackSize(stackSize);
2203} 2509}
2204 2510
2205rule__LowerBoundedScopeDefinition__Alternatives_1 2511rule__LowerBoundedScope__Alternatives_1
2206 @init { 2512 @init {
2207 int stackSize = keepStackSize(); 2513 int stackSize = keepStackSize();
2208 } 2514 }
2209: 2515:
2210 ( 2516 (
2211 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); } 2517 { before(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_0()); }
2212 (rule__LowerBoundedScopeDefinition__Group_1_0__0) 2518 (rule__LowerBoundedScope__Group_1_0__0)
2213 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); } 2519 { after(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_0()); }
2214 ) 2520 )
2215 | 2521 |
2216 ( 2522 (
2217 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_1()); } 2523 { before(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_1()); }
2218 (rule__LowerBoundedScopeDefinition__Group_1_1__0) 2524 (rule__LowerBoundedScope__Group_1_1__0)
2219 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_1()); } 2525 { after(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_1()); }
2220 ) 2526 )
2221; 2527;
2222finally { 2528finally {
@@ -2244,21 +2550,60 @@ finally {
2244 restoreStackSize(stackSize); 2550 restoreStackSize(stackSize);
2245} 2551}
2246 2552
2247rule__QualifiedName__Alternatives 2553rule__QualifiedNameSegment__Alternatives
2248 @init { 2554 @init {
2249 int stackSize = keepStackSize(); 2555 int stackSize = keepStackSize();
2250 } 2556 }
2251: 2557:
2252 ( 2558 (
2253 { before(grammarAccess.getQualifiedNameAccess().getGroup_0()); } 2559 { before(grammarAccess.getQualifiedNameSegmentAccess().getIDTerminalRuleCall_0()); }
2254 (rule__QualifiedName__Group_0__0) 2560 RULE_ID
2255 { after(grammarAccess.getQualifiedNameAccess().getGroup_0()); } 2561 { after(grammarAccess.getQualifiedNameSegmentAccess().getIDTerminalRuleCall_0()); }
2256 ) 2562 )
2257 | 2563 |
2258 ( 2564 (
2259 { before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); } 2565 { before(grammarAccess.getQualifiedNameSegmentAccess().getQUOTED_IDTerminalRuleCall_1()); }
2260 RULE_QUOTED_ID 2566 RULE_QUOTED_ID
2261 { after(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); } 2567 { after(grammarAccess.getQualifiedNameSegmentAccess().getQUOTED_IDTerminalRuleCall_1()); }
2568 )
2569 |
2570 (
2571 { before(grammarAccess.getQualifiedNameSegmentAccess().getObjectKeyword_2()); }
2572 Object
2573 { after(grammarAccess.getQualifiedNameSegmentAccess().getObjectKeyword_2()); }
2574 )
2575;
2576finally {
2577 restoreStackSize(stackSize);
2578}
2579
2580rule__AttributeKind__Alternatives
2581 @init {
2582 int stackSize = keepStackSize();
2583 }
2584:
2585 (
2586 { before(grammarAccess.getAttributeKindAccess().getFUNCTIONALEnumLiteralDeclaration_0()); }
2587 (Functional)
2588 { after(grammarAccess.getAttributeKindAccess().getFUNCTIONALEnumLiteralDeclaration_0()); }
2589 )
2590 |
2591 (
2592 { before(grammarAccess.getAttributeKindAccess().getERROREnumLiteralDeclaration_1()); }
2593 (Error)
2594 { after(grammarAccess.getAttributeKindAccess().getERROREnumLiteralDeclaration_1()); }
2595 )
2596 |
2597 (
2598 { before(grammarAccess.getAttributeKindAccess().getROOTEnumLiteralDeclaration_2()); }
2599 (Root)
2600 { after(grammarAccess.getAttributeKindAccess().getROOTEnumLiteralDeclaration_2()); }
2601 )
2602 |
2603 (
2604 { before(grammarAccess.getAttributeKindAccess().getCONTAINMENTEnumLiteralDeclaration_3()); }
2605 (Containment)
2606 { after(grammarAccess.getAttributeKindAccess().getCONTAINMENTEnumLiteralDeclaration_3()); }
2262 ) 2607 )
2263; 2608;
2264finally { 2609finally {
@@ -2271,15 +2616,15 @@ rule__ComparisonOperator__Alternatives
2271 } 2616 }
2272: 2617:
2273 ( 2618 (
2274 { before(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); } 2619 { before(grammarAccess.getComparisonOperatorAccess().getEQUALSEnumLiteralDeclaration_0()); }
2275 (EqualsSignEqualsSign) 2620 (EqualsSignEqualsSign)
2276 { after(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); } 2621 { after(grammarAccess.getComparisonOperatorAccess().getEQUALSEnumLiteralDeclaration_0()); }
2277 ) 2622 )
2278 | 2623 |
2279 ( 2624 (
2280 { before(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); } 2625 { before(grammarAccess.getComparisonOperatorAccess().getNOT_EQUALSEnumLiteralDeclaration_1()); }
2281 (ExclamationMarkEqualsSign) 2626 (ExclamationMarkEqualsSign)
2282 { after(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); } 2627 { after(grammarAccess.getComparisonOperatorAccess().getNOT_EQUALSEnumLiteralDeclaration_1()); }
2283 ) 2628 )
2284 | 2629 |
2285 ( 2630 (
@@ -2289,9 +2634,9 @@ rule__ComparisonOperator__Alternatives
2289 ) 2634 )
2290 | 2635 |
2291 ( 2636 (
2292 { before(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); } 2637 { before(grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_3()); }
2293 (LessThanSignEqualsSign) 2638 (LessThanSignEqualsSign)
2294 { after(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); } 2639 { after(grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_3()); }
2295 ) 2640 )
2296 | 2641 |
2297 ( 2642 (
@@ -2301,9 +2646,9 @@ rule__ComparisonOperator__Alternatives
2301 ) 2646 )
2302 | 2647 |
2303 ( 2648 (
2304 { before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); } 2649 { before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_5()); }
2305 (GreaterThanSignEqualsSign) 2650 (GreaterThanSignEqualsSign)
2306 { after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); } 2651 { after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_5()); }
2307 ) 2652 )
2308 | 2653 |
2309 ( 2654 (
@@ -2322,15 +2667,15 @@ rule__AdditiveBinaryOperator__Alternatives
2322 } 2667 }
2323: 2668:
2324 ( 2669 (
2325 { before(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); } 2670 { before(grammarAccess.getAdditiveBinaryOperatorAccess().getPLUSEnumLiteralDeclaration_0()); }
2326 (PlusSign) 2671 (PlusSign)
2327 { after(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); } 2672 { after(grammarAccess.getAdditiveBinaryOperatorAccess().getPLUSEnumLiteralDeclaration_0()); }
2328 ) 2673 )
2329 | 2674 |
2330 ( 2675 (
2331 { before(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); } 2676 { before(grammarAccess.getAdditiveBinaryOperatorAccess().getMINUSEnumLiteralDeclaration_1()); }
2332 (HyphenMinus) 2677 (HyphenMinus)
2333 { after(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); } 2678 { after(grammarAccess.getAdditiveBinaryOperatorAccess().getMINUSEnumLiteralDeclaration_1()); }
2334 ) 2679 )
2335; 2680;
2336finally { 2681finally {
@@ -2343,87 +2688,48 @@ rule__MultiplicativeBinaryOperator__Alternatives
2343 } 2688 }
2344: 2689:
2345 ( 2690 (
2346 { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); } 2691 { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULTIPLYEnumLiteralDeclaration_0()); }
2347 (Asterisk) 2692 (Asterisk)
2348 { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); } 2693 { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULTIPLYEnumLiteralDeclaration_0()); }
2349 ) 2694 )
2350 | 2695 |
2351 ( 2696 (
2352 { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); } 2697 { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVIDEEnumLiteralDeclaration_1()); }
2353 (Solidus) 2698 (Solidus)
2354 { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); } 2699 { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVIDEEnumLiteralDeclaration_1()); }
2355 ) 2700 )
2356; 2701;
2357finally { 2702finally {
2358 restoreStackSize(stackSize); 2703 restoreStackSize(stackSize);
2359} 2704}
2360 2705
2361rule__UnaryOp__Alternatives 2706rule__UnaryOperator__Alternatives
2362 @init { 2707 @init {
2363 int stackSize = keepStackSize(); 2708 int stackSize = keepStackSize();
2364 } 2709 }
2365: 2710:
2366 ( 2711 (
2367 { before(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); } 2712 { before(grammarAccess.getUnaryOperatorAccess().getNOTEnumLiteralDeclaration_0()); }
2368 (ExclamationMark) 2713 (ExclamationMark)
2369 { after(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); } 2714 { after(grammarAccess.getUnaryOperatorAccess().getNOTEnumLiteralDeclaration_0()); }
2370 ) 2715 )
2371 | 2716 |
2372 ( 2717 (
2373 { before(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); } 2718 { before(grammarAccess.getUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_1()); }
2374 (PlusSign) 2719 (PlusSign)
2375 { after(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); } 2720 { after(grammarAccess.getUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_1()); }
2376 ) 2721 )
2377 | 2722 |
2378 ( 2723 (
2379 { before(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); } 2724 { before(grammarAccess.getUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_2()); }
2380 (HyphenMinus) 2725 (HyphenMinus)
2381 { after(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); } 2726 { after(grammarAccess.getUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_2()); }
2382 )
2383 |
2384 (
2385 { before(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); }
2386 (May)
2387 { after(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); }
2388 )
2389 |
2390 (
2391 { before(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); }
2392 (Must)
2393 { after(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); }
2394 )
2395 |
2396 (
2397 { before(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); }
2398 (Current)
2399 { after(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); }
2400 )
2401;
2402finally {
2403 restoreStackSize(stackSize);
2404}
2405
2406rule__Quantifier__Alternatives
2407 @init {
2408 int stackSize = keepStackSize();
2409 }
2410:
2411 (
2412 { before(grammarAccess.getQuantifierAccess().getEXISTSEnumLiteralDeclaration_0()); }
2413 (Exists)
2414 { after(grammarAccess.getQuantifierAccess().getEXISTSEnumLiteralDeclaration_0()); }
2415 )
2416 |
2417 (
2418 { before(grammarAccess.getQuantifierAccess().getFORALLEnumLiteralDeclaration_1()); }
2419 (Forall)
2420 { after(grammarAccess.getQuantifierAccess().getFORALLEnumLiteralDeclaration_1()); }
2421 ) 2727 )
2422 | 2728 |
2423 ( 2729 (
2424 { before(grammarAccess.getQuantifierAccess().getCOUNTEnumLiteralDeclaration_2()); } 2730 { before(grammarAccess.getUnaryOperatorAccess().getMAYBEEnumLiteralDeclaration_3()); }
2425 (Count) 2731 (QuestionMark)
2426 { after(grammarAccess.getQuantifierAccess().getCOUNTEnumLiteralDeclaration_2()); } 2732 { after(grammarAccess.getUnaryOperatorAccess().getMAYBEEnumLiteralDeclaration_3()); }
2427 ) 2733 )
2428; 2734;
2429finally { 2735finally {
@@ -2469,68 +2775,500 @@ rule__ObjectiveKind__Alternatives
2469 } 2775 }
2470: 2776:
2471 ( 2777 (
2472 { before(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); } 2778 { before(grammarAccess.getObjectiveKindAccess().getMINIMIZATIONEnumLiteralDeclaration_0()); }
2473 (Minimize) 2779 (Minimize)
2474 { after(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); } 2780 { after(grammarAccess.getObjectiveKindAccess().getMINIMIZATIONEnumLiteralDeclaration_0()); }
2475 ) 2781 )
2476 | 2782 |
2477 ( 2783 (
2478 { before(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); } 2784 { before(grammarAccess.getObjectiveKindAccess().getMAXIMIZATIONEnumLiteralDeclaration_1()); }
2479 (Maximize) 2785 (Maximize)
2480 { after(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); } 2786 { after(grammarAccess.getObjectiveKindAccess().getMAXIMIZATIONEnumLiteralDeclaration_1()); }
2481 ) 2787 )
2482; 2788;
2483finally { 2789finally {
2484 restoreStackSize(stackSize); 2790 restoreStackSize(stackSize);
2485} 2791}
2486 2792
2487rule__Statement__Group__0 2793rule__Problem__Group__0
2488 @init { 2794 @init {
2489 int stackSize = keepStackSize(); 2795 int stackSize = keepStackSize();
2490 } 2796 }
2491: 2797:
2492 rule__Statement__Group__0__Impl 2798 rule__Problem__Group__0__Impl
2493 rule__Statement__Group__1 2799 rule__Problem__Group__1
2494; 2800;
2495finally { 2801finally {
2496 restoreStackSize(stackSize); 2802 restoreStackSize(stackSize);
2497} 2803}
2498 2804
2499rule__Statement__Group__0__Impl 2805rule__Problem__Group__0__Impl
2500 @init { 2806 @init {
2501 int stackSize = keepStackSize(); 2807 int stackSize = keepStackSize();
2502 } 2808 }
2503: 2809:
2504( 2810(
2505 { before(grammarAccess.getStatementAccess().getAlternatives_0()); } 2811 { before(grammarAccess.getProblemAccess().getGroup_0()); }
2506 (rule__Statement__Alternatives_0) 2812 (rule__Problem__Group_0__0)?
2507 { after(grammarAccess.getStatementAccess().getAlternatives_0()); } 2813 { after(grammarAccess.getProblemAccess().getGroup_0()); }
2508) 2814)
2509; 2815;
2510finally { 2816finally {
2511 restoreStackSize(stackSize); 2817 restoreStackSize(stackSize);
2512} 2818}
2513 2819
2514rule__Statement__Group__1 2820rule__Problem__Group__1
2515 @init { 2821 @init {
2516 int stackSize = keepStackSize(); 2822 int stackSize = keepStackSize();
2517 } 2823 }
2518: 2824:
2519 rule__Statement__Group__1__Impl 2825 rule__Problem__Group__1__Impl
2826 rule__Problem__Group__2
2520; 2827;
2521finally { 2828finally {
2522 restoreStackSize(stackSize); 2829 restoreStackSize(stackSize);
2523} 2830}
2524 2831
2525rule__Statement__Group__1__Impl 2832rule__Problem__Group__1__Impl
2526 @init { 2833 @init {
2527 int stackSize = keepStackSize(); 2834 int stackSize = keepStackSize();
2528 } 2835 }
2529: 2836:
2530( 2837(
2531 { before(grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); } 2838 { before(grammarAccess.getProblemAccess().getImportsAssignment_1()); }
2839 (rule__Problem__ImportsAssignment_1)*
2840 { after(grammarAccess.getProblemAccess().getImportsAssignment_1()); }
2841)
2842;
2843finally {
2844 restoreStackSize(stackSize);
2845}
2846
2847rule__Problem__Group__2
2848 @init {
2849 int stackSize = keepStackSize();
2850 }
2851:
2852 rule__Problem__Group__2__Impl
2853;
2854finally {
2855 restoreStackSize(stackSize);
2856}
2857
2858rule__Problem__Group__2__Impl
2859 @init {
2860 int stackSize = keepStackSize();
2861 }
2862:
2863(
2864 { before(grammarAccess.getProblemAccess().getStatementsAssignment_2()); }
2865 (rule__Problem__StatementsAssignment_2)*
2866 { after(grammarAccess.getProblemAccess().getStatementsAssignment_2()); }
2867)
2868;
2869finally {
2870 restoreStackSize(stackSize);
2871}
2872
2873
2874rule__Problem__Group_0__0
2875 @init {
2876 int stackSize = keepStackSize();
2877 }
2878:
2879 rule__Problem__Group_0__0__Impl
2880 rule__Problem__Group_0__1
2881;
2882finally {
2883 restoreStackSize(stackSize);
2884}
2885
2886rule__Problem__Group_0__0__Impl
2887 @init {
2888 int stackSize = keepStackSize();
2889 }
2890:
2891(
2892 { before(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); }
2893 Problem
2894 { after(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); }
2895)
2896;
2897finally {
2898 restoreStackSize(stackSize);
2899}
2900
2901rule__Problem__Group_0__1
2902 @init {
2903 int stackSize = keepStackSize();
2904 }
2905:
2906 rule__Problem__Group_0__1__Impl
2907 rule__Problem__Group_0__2
2908;
2909finally {
2910 restoreStackSize(stackSize);
2911}
2912
2913rule__Problem__Group_0__1__Impl
2914 @init {
2915 int stackSize = keepStackSize();
2916 }
2917:
2918(
2919 { before(grammarAccess.getProblemAccess().getNameAssignment_0_1()); }
2920 (rule__Problem__NameAssignment_0_1)
2921 { after(grammarAccess.getProblemAccess().getNameAssignment_0_1()); }
2922)
2923;
2924finally {
2925 restoreStackSize(stackSize);
2926}
2927
2928rule__Problem__Group_0__2
2929 @init {
2930 int stackSize = keepStackSize();
2931 }
2932:
2933 rule__Problem__Group_0__2__Impl
2934;
2935finally {
2936 restoreStackSize(stackSize);
2937}
2938
2939rule__Problem__Group_0__2__Impl
2940 @init {
2941 int stackSize = keepStackSize();
2942 }
2943:
2944(
2945 { before(grammarAccess.getProblemAccess().getFULL_STOPTerminalRuleCall_0_2()); }
2532 RULE_FULL_STOP 2946 RULE_FULL_STOP
2533 { after(grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); } 2947 { after(grammarAccess.getProblemAccess().getFULL_STOPTerminalRuleCall_0_2()); }
2948)
2949;
2950finally {
2951 restoreStackSize(stackSize);
2952}
2953
2954
2955rule__UriImport__Group__0
2956 @init {
2957 int stackSize = keepStackSize();
2958 }
2959:
2960 rule__UriImport__Group__0__Impl
2961 rule__UriImport__Group__1
2962;
2963finally {
2964 restoreStackSize(stackSize);
2965}
2966
2967rule__UriImport__Group__0__Impl
2968 @init {
2969 int stackSize = keepStackSize();
2970 }
2971:
2972(
2973 { before(grammarAccess.getUriImportAccess().getImportKeyword_0()); }
2974 Import
2975 { after(grammarAccess.getUriImportAccess().getImportKeyword_0()); }
2976)
2977;
2978finally {
2979 restoreStackSize(stackSize);
2980}
2981
2982rule__UriImport__Group__1
2983 @init {
2984 int stackSize = keepStackSize();
2985 }
2986:
2987 rule__UriImport__Group__1__Impl
2988 rule__UriImport__Group__2
2989;
2990finally {
2991 restoreStackSize(stackSize);
2992}
2993
2994rule__UriImport__Group__1__Impl
2995 @init {
2996 int stackSize = keepStackSize();
2997 }
2998:
2999(
3000 { before(grammarAccess.getUriImportAccess().getUriAssignment_1()); }
3001 (rule__UriImport__UriAssignment_1)
3002 { after(grammarAccess.getUriImportAccess().getUriAssignment_1()); }
3003)
3004;
3005finally {
3006 restoreStackSize(stackSize);
3007}
3008
3009rule__UriImport__Group__2
3010 @init {
3011 int stackSize = keepStackSize();
3012 }
3013:
3014 rule__UriImport__Group__2__Impl
3015 rule__UriImport__Group__3
3016;
3017finally {
3018 restoreStackSize(stackSize);
3019}
3020
3021rule__UriImport__Group__2__Impl
3022 @init {
3023 int stackSize = keepStackSize();
3024 }
3025:
3026(
3027 { before(grammarAccess.getUriImportAccess().getGroup_2()); }
3028 (rule__UriImport__Group_2__0)
3029 { after(grammarAccess.getUriImportAccess().getGroup_2()); }
3030)
3031;
3032finally {
3033 restoreStackSize(stackSize);
3034}
3035
3036rule__UriImport__Group__3
3037 @init {
3038 int stackSize = keepStackSize();
3039 }
3040:
3041 rule__UriImport__Group__3__Impl
3042;
3043finally {
3044 restoreStackSize(stackSize);
3045}
3046
3047rule__UriImport__Group__3__Impl
3048 @init {
3049 int stackSize = keepStackSize();
3050 }
3051:
3052(
3053 { before(grammarAccess.getUriImportAccess().getFULL_STOPTerminalRuleCall_3()); }
3054 RULE_FULL_STOP
3055 { after(grammarAccess.getUriImportAccess().getFULL_STOPTerminalRuleCall_3()); }
3056)
3057;
3058finally {
3059 restoreStackSize(stackSize);
3060}
3061
3062
3063rule__UriImport__Group_2__0
3064 @init {
3065 int stackSize = keepStackSize();
3066 }
3067:
3068 rule__UriImport__Group_2__0__Impl
3069 rule__UriImport__Group_2__1
3070;
3071finally {
3072 restoreStackSize(stackSize);
3073}
3074
3075rule__UriImport__Group_2__0__Impl
3076 @init {
3077 int stackSize = keepStackSize();
3078 }
3079:
3080(
3081 { before(grammarAccess.getUriImportAccess().getAsKeyword_2_0()); }
3082 As
3083 { after(grammarAccess.getUriImportAccess().getAsKeyword_2_0()); }
3084)
3085;
3086finally {
3087 restoreStackSize(stackSize);
3088}
3089
3090rule__UriImport__Group_2__1
3091 @init {
3092 int stackSize = keepStackSize();
3093 }
3094:
3095 rule__UriImport__Group_2__1__Impl
3096;
3097finally {
3098 restoreStackSize(stackSize);
3099}
3100
3101rule__UriImport__Group_2__1__Impl
3102 @init {
3103 int stackSize = keepStackSize();
3104 }
3105:
3106(
3107 { before(grammarAccess.getUriImportAccess().getAliasAssignment_2_1()); }
3108 (rule__UriImport__AliasAssignment_2_1)
3109 { after(grammarAccess.getUriImportAccess().getAliasAssignment_2_1()); }
3110)
3111;
3112finally {
3113 restoreStackSize(stackSize);
3114}
3115
3116
3117rule__NamespaceImport__Group__0
3118 @init {
3119 int stackSize = keepStackSize();
3120 }
3121:
3122 rule__NamespaceImport__Group__0__Impl
3123 rule__NamespaceImport__Group__1
3124;
3125finally {
3126 restoreStackSize(stackSize);
3127}
3128
3129rule__NamespaceImport__Group__0__Impl
3130 @init {
3131 int stackSize = keepStackSize();
3132 }
3133:
3134(
3135 { before(grammarAccess.getNamespaceImportAccess().getImportKeyword_0()); }
3136 Import
3137 { after(grammarAccess.getNamespaceImportAccess().getImportKeyword_0()); }
3138)
3139;
3140finally {
3141 restoreStackSize(stackSize);
3142}
3143
3144rule__NamespaceImport__Group__1
3145 @init {
3146 int stackSize = keepStackSize();
3147 }
3148:
3149 rule__NamespaceImport__Group__1__Impl
3150 rule__NamespaceImport__Group__2
3151;
3152finally {
3153 restoreStackSize(stackSize);
3154}
3155
3156rule__NamespaceImport__Group__1__Impl
3157 @init {
3158 int stackSize = keepStackSize();
3159 }
3160:
3161(
3162 { before(grammarAccess.getNamespaceImportAccess().getImportedNamespaceAssignment_1()); }
3163 (rule__NamespaceImport__ImportedNamespaceAssignment_1)
3164 { after(grammarAccess.getNamespaceImportAccess().getImportedNamespaceAssignment_1()); }
3165)
3166;
3167finally {
3168 restoreStackSize(stackSize);
3169}
3170
3171rule__NamespaceImport__Group__2
3172 @init {
3173 int stackSize = keepStackSize();
3174 }
3175:
3176 rule__NamespaceImport__Group__2__Impl
3177 rule__NamespaceImport__Group__3
3178;
3179finally {
3180 restoreStackSize(stackSize);
3181}
3182
3183rule__NamespaceImport__Group__2__Impl
3184 @init {
3185 int stackSize = keepStackSize();
3186 }
3187:
3188(
3189 { before(grammarAccess.getNamespaceImportAccess().getGroup_2()); }
3190 (rule__NamespaceImport__Group_2__0)
3191 { after(grammarAccess.getNamespaceImportAccess().getGroup_2()); }
3192)
3193;
3194finally {
3195 restoreStackSize(stackSize);
3196}
3197
3198rule__NamespaceImport__Group__3
3199 @init {
3200 int stackSize = keepStackSize();
3201 }
3202:
3203 rule__NamespaceImport__Group__3__Impl
3204;
3205finally {
3206 restoreStackSize(stackSize);
3207}
3208
3209rule__NamespaceImport__Group__3__Impl
3210 @init {
3211 int stackSize = keepStackSize();
3212 }
3213:
3214(
3215 { before(grammarAccess.getNamespaceImportAccess().getFULL_STOPTerminalRuleCall_3()); }
3216 RULE_FULL_STOP
3217 { after(grammarAccess.getNamespaceImportAccess().getFULL_STOPTerminalRuleCall_3()); }
3218)
3219;
3220finally {
3221 restoreStackSize(stackSize);
3222}
3223
3224
3225rule__NamespaceImport__Group_2__0
3226 @init {
3227 int stackSize = keepStackSize();
3228 }
3229:
3230 rule__NamespaceImport__Group_2__0__Impl
3231 rule__NamespaceImport__Group_2__1
3232;
3233finally {
3234 restoreStackSize(stackSize);
3235}
3236
3237rule__NamespaceImport__Group_2__0__Impl
3238 @init {
3239 int stackSize = keepStackSize();
3240 }
3241:
3242(
3243 { before(grammarAccess.getNamespaceImportAccess().getAsKeyword_2_0()); }
3244 As
3245 { after(grammarAccess.getNamespaceImportAccess().getAsKeyword_2_0()); }
3246)
3247;
3248finally {
3249 restoreStackSize(stackSize);
3250}
3251
3252rule__NamespaceImport__Group_2__1
3253 @init {
3254 int stackSize = keepStackSize();
3255 }
3256:
3257 rule__NamespaceImport__Group_2__1__Impl
3258;
3259finally {
3260 restoreStackSize(stackSize);
3261}
3262
3263rule__NamespaceImport__Group_2__1__Impl
3264 @init {
3265 int stackSize = keepStackSize();
3266 }
3267:
3268(
3269 { before(grammarAccess.getNamespaceImportAccess().getAliasAssignment_2_1()); }
3270 (rule__NamespaceImport__AliasAssignment_2_1)
3271 { after(grammarAccess.getNamespaceImportAccess().getAliasAssignment_2_1()); }
2534) 3272)
2535; 3273;
2536finally { 3274finally {
@@ -2571,6 +3309,7 @@ rule__AssertionOrDefinition__Group__1
2571 } 3309 }
2572: 3310:
2573 rule__AssertionOrDefinition__Group__1__Impl 3311 rule__AssertionOrDefinition__Group__1__Impl
3312 rule__AssertionOrDefinition__Group__2
2574; 3313;
2575finally { 3314finally {
2576 restoreStackSize(stackSize); 3315 restoreStackSize(stackSize);
@@ -2583,7 +3322,7 @@ rule__AssertionOrDefinition__Group__1__Impl
2583: 3322:
2584( 3323(
2585 { before(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); } 3324 { before(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); }
2586 (rule__AssertionOrDefinition__Alternatives_1)? 3325 (rule__AssertionOrDefinition__Alternatives_1)
2587 { after(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); } 3326 { after(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); }
2588) 3327)
2589; 3328;
@@ -2591,6 +3330,32 @@ finally {
2591 restoreStackSize(stackSize); 3330 restoreStackSize(stackSize);
2592} 3331}
2593 3332
3333rule__AssertionOrDefinition__Group__2
3334 @init {
3335 int stackSize = keepStackSize();
3336 }
3337:
3338 rule__AssertionOrDefinition__Group__2__Impl
3339;
3340finally {
3341 restoreStackSize(stackSize);
3342}
3343
3344rule__AssertionOrDefinition__Group__2__Impl
3345 @init {
3346 int stackSize = keepStackSize();
3347 }
3348:
3349(
3350 { before(grammarAccess.getAssertionOrDefinitionAccess().getFULL_STOPTerminalRuleCall_2()); }
3351 RULE_FULL_STOP
3352 { after(grammarAccess.getAssertionOrDefinitionAccess().getFULL_STOPTerminalRuleCall_2()); }
3353)
3354;
3355finally {
3356 restoreStackSize(stackSize);
3357}
3358
2594 3359
2595rule__AssertionOrDefinition__Group_1_0__0 3360rule__AssertionOrDefinition__Group_1_0__0
2596 @init { 3361 @init {
@@ -2610,9 +3375,9 @@ rule__AssertionOrDefinition__Group_1_0__0__Impl
2610 } 3375 }
2611: 3376:
2612( 3377(
2613 { before(grammarAccess.getAssertionOrDefinitionAccess().getInterpretationBodyAction_1_0_0()); } 3378 { before(grammarAccess.getAssertionOrDefinitionAccess().getAssertionExpressionAction_1_0_0()); }
2614 () 3379 ()
2615 { after(grammarAccess.getAssertionOrDefinitionAccess().getInterpretationBodyAction_1_0_0()); } 3380 { after(grammarAccess.getAssertionOrDefinitionAccess().getAssertionExpressionAction_1_0_0()); }
2616) 3381)
2617; 3382;
2618finally { 3383finally {
@@ -2625,7 +3390,6 @@ rule__AssertionOrDefinition__Group_1_0__1
2625 } 3390 }
2626: 3391:
2627 rule__AssertionOrDefinition__Group_1_0__1__Impl 3392 rule__AssertionOrDefinition__Group_1_0__1__Impl
2628 rule__AssertionOrDefinition__Group_1_0__2
2629; 3393;
2630finally { 3394finally {
2631 restoreStackSize(stackSize); 3395 restoreStackSize(stackSize);
@@ -2637,35 +3401,63 @@ rule__AssertionOrDefinition__Group_1_0__1__Impl
2637 } 3401 }
2638: 3402:
2639( 3403(
2640 { before(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1()); } 3404 { before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); }
3405 (rule__AssertionOrDefinition__Group_1_0_1__0)?
3406 { after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); }
3407)
3408;
3409finally {
3410 restoreStackSize(stackSize);
3411}
3412
3413
3414rule__AssertionOrDefinition__Group_1_0_1__0
3415 @init {
3416 int stackSize = keepStackSize();
3417 }
3418:
3419 rule__AssertionOrDefinition__Group_1_0_1__0__Impl
3420 rule__AssertionOrDefinition__Group_1_0_1__1
3421;
3422finally {
3423 restoreStackSize(stackSize);
3424}
3425
3426rule__AssertionOrDefinition__Group_1_0_1__0__Impl
3427 @init {
3428 int stackSize = keepStackSize();
3429 }
3430:
3431(
3432 { before(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); }
2641 Colon 3433 Colon
2642 { after(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1()); } 3434 { after(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); }
2643) 3435)
2644; 3436;
2645finally { 3437finally {
2646 restoreStackSize(stackSize); 3438 restoreStackSize(stackSize);
2647} 3439}
2648 3440
2649rule__AssertionOrDefinition__Group_1_0__2 3441rule__AssertionOrDefinition__Group_1_0_1__1
2650 @init { 3442 @init {
2651 int stackSize = keepStackSize(); 3443 int stackSize = keepStackSize();
2652 } 3444 }
2653: 3445:
2654 rule__AssertionOrDefinition__Group_1_0__2__Impl 3446 rule__AssertionOrDefinition__Group_1_0_1__1__Impl
2655; 3447;
2656finally { 3448finally {
2657 restoreStackSize(stackSize); 3449 restoreStackSize(stackSize);
2658} 3450}
2659 3451
2660rule__AssertionOrDefinition__Group_1_0__2__Impl 3452rule__AssertionOrDefinition__Group_1_0_1__1__Impl
2661 @init { 3453 @init {
2662 int stackSize = keepStackSize(); 3454 int stackSize = keepStackSize();
2663 } 3455 }
2664: 3456:
2665( 3457(
2666 { before(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_2()); } 3458 { before(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); }
2667 (rule__AssertionOrDefinition__RangeAssignment_1_0_2) 3459 (rule__AssertionOrDefinition__RangeAssignment_1_0_1_1)
2668 { after(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_2()); } 3460 { after(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); }
2669) 3461)
2670; 3462;
2671finally { 3463finally {
@@ -2772,9 +3564,9 @@ rule__AssertionOrDefinition__Group_1_2__0__Impl
2772 } 3564 }
2773: 3565:
2774( 3566(
2775 { before(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0()); } 3567 { before(grammarAccess.getAssertionOrDefinitionAccess().getFunctionDefinitionHeadAction_1_2_0()); }
2776 () 3568 ()
2777 { after(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0()); } 3569 { after(grammarAccess.getAssertionOrDefinitionAccess().getFunctionDefinitionHeadAction_1_2_0()); }
2778) 3570)
2779; 3571;
2780finally { 3572finally {
@@ -2799,9 +3591,9 @@ rule__AssertionOrDefinition__Group_1_2__1__Impl
2799 } 3591 }
2800: 3592:
2801( 3593(
2802 { before(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); } 3594 { before(grammarAccess.getAssertionOrDefinitionAccess().getColonEqualsSignKeyword_1_2_1()); }
2803 EqualsSign 3595 ColonEqualsSign
2804 { after(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); } 3596 { after(grammarAccess.getAssertionOrDefinitionAccess().getColonEqualsSignKeyword_1_2_1()); }
2805) 3597)
2806; 3598;
2807finally { 3599finally {
@@ -2922,6 +3714,7 @@ rule__PredicateDefinition__Group__3
2922 } 3714 }
2923: 3715:
2924 rule__PredicateDefinition__Group__3__Impl 3716 rule__PredicateDefinition__Group__3__Impl
3717 rule__PredicateDefinition__Group__4
2925; 3718;
2926finally { 3719finally {
2927 restoreStackSize(stackSize); 3720 restoreStackSize(stackSize);
@@ -2942,6 +3735,32 @@ finally {
2942 restoreStackSize(stackSize); 3735 restoreStackSize(stackSize);
2943} 3736}
2944 3737
3738rule__PredicateDefinition__Group__4
3739 @init {
3740 int stackSize = keepStackSize();
3741 }
3742:
3743 rule__PredicateDefinition__Group__4__Impl
3744;
3745finally {
3746 restoreStackSize(stackSize);
3747}
3748
3749rule__PredicateDefinition__Group__4__Impl
3750 @init {
3751 int stackSize = keepStackSize();
3752 }
3753:
3754(
3755 { before(grammarAccess.getPredicateDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); }
3756 RULE_FULL_STOP
3757 { after(grammarAccess.getPredicateDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); }
3758)
3759;
3760finally {
3761 restoreStackSize(stackSize);
3762}
3763
2945 3764
2946rule__PredicateDefinition__Group_0_0__0 3765rule__PredicateDefinition__Group_0_0__0
2947 @init { 3766 @init {
@@ -3051,107 +3870,134 @@ finally {
3051} 3870}
3052 3871
3053 3872
3054rule__UnnamedErrorPrediateDefinition__Group__0 3873rule__UnnamedErrorPredicateDefintion__Group__0
3055 @init { 3874 @init {
3056 int stackSize = keepStackSize(); 3875 int stackSize = keepStackSize();
3057 } 3876 }
3058: 3877:
3059 rule__UnnamedErrorPrediateDefinition__Group__0__Impl 3878 rule__UnnamedErrorPredicateDefintion__Group__0__Impl
3060 rule__UnnamedErrorPrediateDefinition__Group__1 3879 rule__UnnamedErrorPredicateDefintion__Group__1
3061; 3880;
3062finally { 3881finally {
3063 restoreStackSize(stackSize); 3882 restoreStackSize(stackSize);
3064} 3883}
3065 3884
3066rule__UnnamedErrorPrediateDefinition__Group__0__Impl 3885rule__UnnamedErrorPredicateDefintion__Group__0__Impl
3067 @init { 3886 @init {
3068 int stackSize = keepStackSize(); 3887 int stackSize = keepStackSize();
3069 } 3888 }
3070: 3889:
3071( 3890(
3072 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); } 3891 { before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getErrorKeyword_0()); }
3073 Error 3892 Error
3074 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); } 3893 { after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getErrorKeyword_0()); }
3075) 3894)
3076; 3895;
3077finally { 3896finally {
3078 restoreStackSize(stackSize); 3897 restoreStackSize(stackSize);
3079} 3898}
3080 3899
3081rule__UnnamedErrorPrediateDefinition__Group__1 3900rule__UnnamedErrorPredicateDefintion__Group__1
3082 @init { 3901 @init {
3083 int stackSize = keepStackSize(); 3902 int stackSize = keepStackSize();
3084 } 3903 }
3085: 3904:
3086 rule__UnnamedErrorPrediateDefinition__Group__1__Impl 3905 rule__UnnamedErrorPredicateDefintion__Group__1__Impl
3087 rule__UnnamedErrorPrediateDefinition__Group__2 3906 rule__UnnamedErrorPredicateDefintion__Group__2
3088; 3907;
3089finally { 3908finally {
3090 restoreStackSize(stackSize); 3909 restoreStackSize(stackSize);
3091} 3910}
3092 3911
3093rule__UnnamedErrorPrediateDefinition__Group__1__Impl 3912rule__UnnamedErrorPredicateDefintion__Group__1__Impl
3094 @init { 3913 @init {
3095 int stackSize = keepStackSize(); 3914 int stackSize = keepStackSize();
3096 } 3915 }
3097: 3916:
3098( 3917(
3099 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); } 3918 { before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListAssignment_1()); }
3100 (rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1) 3919 (rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1)
3101 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); } 3920 { after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListAssignment_1()); }
3102) 3921)
3103; 3922;
3104finally { 3923finally {
3105 restoreStackSize(stackSize); 3924 restoreStackSize(stackSize);
3106} 3925}
3107 3926
3108rule__UnnamedErrorPrediateDefinition__Group__2 3927rule__UnnamedErrorPredicateDefintion__Group__2
3109 @init { 3928 @init {
3110 int stackSize = keepStackSize(); 3929 int stackSize = keepStackSize();
3111 } 3930 }
3112: 3931:
3113 rule__UnnamedErrorPrediateDefinition__Group__2__Impl 3932 rule__UnnamedErrorPredicateDefintion__Group__2__Impl
3114 rule__UnnamedErrorPrediateDefinition__Group__3 3933 rule__UnnamedErrorPredicateDefintion__Group__3
3115; 3934;
3116finally { 3935finally {
3117 restoreStackSize(stackSize); 3936 restoreStackSize(stackSize);
3118} 3937}
3119 3938
3120rule__UnnamedErrorPrediateDefinition__Group__2__Impl 3939rule__UnnamedErrorPredicateDefintion__Group__2__Impl
3121 @init { 3940 @init {
3122 int stackSize = keepStackSize(); 3941 int stackSize = keepStackSize();
3123 } 3942 }
3124: 3943:
3125( 3944(
3126 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); } 3945 { before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getColonHyphenMinusKeyword_2()); }
3127 ColonHyphenMinus 3946 ColonHyphenMinus
3128 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); } 3947 { after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getColonHyphenMinusKeyword_2()); }
3129) 3948)
3130; 3949;
3131finally { 3950finally {
3132 restoreStackSize(stackSize); 3951 restoreStackSize(stackSize);
3133} 3952}
3134 3953
3135rule__UnnamedErrorPrediateDefinition__Group__3 3954rule__UnnamedErrorPredicateDefintion__Group__3
3136 @init { 3955 @init {
3137 int stackSize = keepStackSize(); 3956 int stackSize = keepStackSize();
3138 } 3957 }
3139: 3958:
3140 rule__UnnamedErrorPrediateDefinition__Group__3__Impl 3959 rule__UnnamedErrorPredicateDefintion__Group__3__Impl
3960 rule__UnnamedErrorPredicateDefintion__Group__4
3141; 3961;
3142finally { 3962finally {
3143 restoreStackSize(stackSize); 3963 restoreStackSize(stackSize);
3144} 3964}
3145 3965
3146rule__UnnamedErrorPrediateDefinition__Group__3__Impl 3966rule__UnnamedErrorPredicateDefintion__Group__3__Impl
3147 @init { 3967 @init {
3148 int stackSize = keepStackSize(); 3968 int stackSize = keepStackSize();
3149 } 3969 }
3150: 3970:
3151( 3971(
3152 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); } 3972 { before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyAssignment_3()); }
3153 (rule__UnnamedErrorPrediateDefinition__BodyAssignment_3) 3973 (rule__UnnamedErrorPredicateDefintion__BodyAssignment_3)
3154 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); } 3974 { after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyAssignment_3()); }
3975)
3976;
3977finally {
3978 restoreStackSize(stackSize);
3979}
3980
3981rule__UnnamedErrorPredicateDefintion__Group__4
3982 @init {
3983 int stackSize = keepStackSize();
3984 }
3985:
3986 rule__UnnamedErrorPredicateDefintion__Group__4__Impl
3987;
3988finally {
3989 restoreStackSize(stackSize);
3990}
3991
3992rule__UnnamedErrorPredicateDefintion__Group__4__Impl
3993 @init {
3994 int stackSize = keepStackSize();
3995 }
3996:
3997(
3998 { before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getFULL_STOPTerminalRuleCall_4()); }
3999 RULE_FULL_STOP
4000 { after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getFULL_STOPTerminalRuleCall_4()); }
3155) 4001)
3156; 4002;
3157finally { 4003finally {
@@ -3159,107 +4005,107 @@ finally {
3159} 4005}
3160 4006
3161 4007
3162rule__DefaultDefinition__Group__0 4008rule__DefaultAssertion__Group__0
3163 @init { 4009 @init {
3164 int stackSize = keepStackSize(); 4010 int stackSize = keepStackSize();
3165 } 4011 }
3166: 4012:
3167 rule__DefaultDefinition__Group__0__Impl 4013 rule__DefaultAssertion__Group__0__Impl
3168 rule__DefaultDefinition__Group__1 4014 rule__DefaultAssertion__Group__1
3169; 4015;
3170finally { 4016finally {
3171 restoreStackSize(stackSize); 4017 restoreStackSize(stackSize);
3172} 4018}
3173 4019
3174rule__DefaultDefinition__Group__0__Impl 4020rule__DefaultAssertion__Group__0__Impl
3175 @init { 4021 @init {
3176 int stackSize = keepStackSize(); 4022 int stackSize = keepStackSize();
3177 } 4023 }
3178: 4024:
3179( 4025(
3180 { before(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); } 4026 { before(grammarAccess.getDefaultAssertionAccess().getDefaultKeyword_0()); }
3181 Default 4027 Default
3182 { after(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); } 4028 { after(grammarAccess.getDefaultAssertionAccess().getDefaultKeyword_0()); }
3183) 4029)
3184; 4030;
3185finally { 4031finally {
3186 restoreStackSize(stackSize); 4032 restoreStackSize(stackSize);
3187} 4033}
3188 4034
3189rule__DefaultDefinition__Group__1 4035rule__DefaultAssertion__Group__1
3190 @init { 4036 @init {
3191 int stackSize = keepStackSize(); 4037 int stackSize = keepStackSize();
3192 } 4038 }
3193: 4039:
3194 rule__DefaultDefinition__Group__1__Impl 4040 rule__DefaultAssertion__Group__1__Impl
3195 rule__DefaultDefinition__Group__2 4041 rule__DefaultAssertion__Group__2
3196; 4042;
3197finally { 4043finally {
3198 restoreStackSize(stackSize); 4044 restoreStackSize(stackSize);
3199} 4045}
3200 4046
3201rule__DefaultDefinition__Group__1__Impl 4047rule__DefaultAssertion__Group__1__Impl
3202 @init { 4048 @init {
3203 int stackSize = keepStackSize(); 4049 int stackSize = keepStackSize();
3204 } 4050 }
3205: 4051:
3206( 4052(
3207 { before(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); } 4053 { before(grammarAccess.getDefaultAssertionAccess().getExpressionAssignment_1()); }
3208 (rule__DefaultDefinition__HeadAssignment_1) 4054 (rule__DefaultAssertion__ExpressionAssignment_1)
3209 { after(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); } 4055 { after(grammarAccess.getDefaultAssertionAccess().getExpressionAssignment_1()); }
3210) 4056)
3211; 4057;
3212finally { 4058finally {
3213 restoreStackSize(stackSize); 4059 restoreStackSize(stackSize);
3214} 4060}
3215 4061
3216rule__DefaultDefinition__Group__2 4062rule__DefaultAssertion__Group__2
3217 @init { 4063 @init {
3218 int stackSize = keepStackSize(); 4064 int stackSize = keepStackSize();
3219 } 4065 }
3220: 4066:
3221 rule__DefaultDefinition__Group__2__Impl 4067 rule__DefaultAssertion__Group__2__Impl
3222 rule__DefaultDefinition__Group__3 4068 rule__DefaultAssertion__Group__3
3223; 4069;
3224finally { 4070finally {
3225 restoreStackSize(stackSize); 4071 restoreStackSize(stackSize);
3226} 4072}
3227 4073
3228rule__DefaultDefinition__Group__2__Impl 4074rule__DefaultAssertion__Group__2__Impl
3229 @init { 4075 @init {
3230 int stackSize = keepStackSize(); 4076 int stackSize = keepStackSize();
3231 } 4077 }
3232: 4078:
3233( 4079(
3234 { before(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); } 4080 { before(grammarAccess.getDefaultAssertionAccess().getGroup_2()); }
3235 Colon 4081 (rule__DefaultAssertion__Group_2__0)?
3236 { after(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); } 4082 { after(grammarAccess.getDefaultAssertionAccess().getGroup_2()); }
3237) 4083)
3238; 4084;
3239finally { 4085finally {
3240 restoreStackSize(stackSize); 4086 restoreStackSize(stackSize);
3241} 4087}
3242 4088
3243rule__DefaultDefinition__Group__3 4089rule__DefaultAssertion__Group__3
3244 @init { 4090 @init {
3245 int stackSize = keepStackSize(); 4091 int stackSize = keepStackSize();
3246 } 4092 }
3247: 4093:
3248 rule__DefaultDefinition__Group__3__Impl 4094 rule__DefaultAssertion__Group__3__Impl
3249; 4095;
3250finally { 4096finally {
3251 restoreStackSize(stackSize); 4097 restoreStackSize(stackSize);
3252} 4098}
3253 4099
3254rule__DefaultDefinition__Group__3__Impl 4100rule__DefaultAssertion__Group__3__Impl
3255 @init { 4101 @init {
3256 int stackSize = keepStackSize(); 4102 int stackSize = keepStackSize();
3257 } 4103 }
3258: 4104:
3259( 4105(
3260 { before(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); } 4106 { before(grammarAccess.getDefaultAssertionAccess().getFULL_STOPTerminalRuleCall_3()); }
3261 (rule__DefaultDefinition__RangeAssignment_3) 4107 RULE_FULL_STOP
3262 { after(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); } 4108 { after(grammarAccess.getDefaultAssertionAccess().getFULL_STOPTerminalRuleCall_3()); }
3263) 4109)
3264; 4110;
3265finally { 4111finally {
@@ -3267,188 +4113,188 @@ finally {
3267} 4113}
3268 4114
3269 4115
3270rule__MetricDefinition__Group__0 4116rule__DefaultAssertion__Group_2__0
3271 @init { 4117 @init {
3272 int stackSize = keepStackSize(); 4118 int stackSize = keepStackSize();
3273 } 4119 }
3274: 4120:
3275 rule__MetricDefinition__Group__0__Impl 4121 rule__DefaultAssertion__Group_2__0__Impl
3276 rule__MetricDefinition__Group__1 4122 rule__DefaultAssertion__Group_2__1
3277; 4123;
3278finally { 4124finally {
3279 restoreStackSize(stackSize); 4125 restoreStackSize(stackSize);
3280} 4126}
3281 4127
3282rule__MetricDefinition__Group__0__Impl 4128rule__DefaultAssertion__Group_2__0__Impl
3283 @init { 4129 @init {
3284 int stackSize = keepStackSize(); 4130 int stackSize = keepStackSize();
3285 } 4131 }
3286: 4132:
3287( 4133(
3288 { before(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); } 4134 { before(grammarAccess.getDefaultAssertionAccess().getColonKeyword_2_0()); }
3289 (rule__MetricDefinition__TypeAssignment_0) 4135 Colon
3290 { after(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); } 4136 { after(grammarAccess.getDefaultAssertionAccess().getColonKeyword_2_0()); }
3291) 4137)
3292; 4138;
3293finally { 4139finally {
3294 restoreStackSize(stackSize); 4140 restoreStackSize(stackSize);
3295} 4141}
3296 4142
3297rule__MetricDefinition__Group__1 4143rule__DefaultAssertion__Group_2__1
3298 @init { 4144 @init {
3299 int stackSize = keepStackSize(); 4145 int stackSize = keepStackSize();
3300 } 4146 }
3301: 4147:
3302 rule__MetricDefinition__Group__1__Impl 4148 rule__DefaultAssertion__Group_2__1__Impl
3303 rule__MetricDefinition__Group__2
3304; 4149;
3305finally { 4150finally {
3306 restoreStackSize(stackSize); 4151 restoreStackSize(stackSize);
3307} 4152}
3308 4153
3309rule__MetricDefinition__Group__1__Impl 4154rule__DefaultAssertion__Group_2__1__Impl
3310 @init { 4155 @init {
3311 int stackSize = keepStackSize(); 4156 int stackSize = keepStackSize();
3312 } 4157 }
3313: 4158:
3314( 4159(
3315 { before(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); } 4160 { before(grammarAccess.getDefaultAssertionAccess().getRangeAssignment_2_1()); }
3316 (rule__MetricDefinition__HeadAssignment_1) 4161 (rule__DefaultAssertion__RangeAssignment_2_1)
3317 { after(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); } 4162 { after(grammarAccess.getDefaultAssertionAccess().getRangeAssignment_2_1()); }
3318) 4163)
3319; 4164;
3320finally { 4165finally {
3321 restoreStackSize(stackSize); 4166 restoreStackSize(stackSize);
3322} 4167}
3323 4168
3324rule__MetricDefinition__Group__2 4169
4170rule__FunctionDefinition__Group__0
3325 @init { 4171 @init {
3326 int stackSize = keepStackSize(); 4172 int stackSize = keepStackSize();
3327 } 4173 }
3328: 4174:
3329 rule__MetricDefinition__Group__2__Impl 4175 rule__FunctionDefinition__Group__0__Impl
3330 rule__MetricDefinition__Group__3 4176 rule__FunctionDefinition__Group__1
3331; 4177;
3332finally { 4178finally {
3333 restoreStackSize(stackSize); 4179 restoreStackSize(stackSize);
3334} 4180}
3335 4181
3336rule__MetricDefinition__Group__2__Impl 4182rule__FunctionDefinition__Group__0__Impl
3337 @init { 4183 @init {
3338 int stackSize = keepStackSize(); 4184 int stackSize = keepStackSize();
3339 } 4185 }
3340: 4186:
3341( 4187(
3342 { before(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); } 4188 { before(grammarAccess.getFunctionDefinitionAccess().getResultTypeAssignment_0()); }
3343 EqualsSign 4189 (rule__FunctionDefinition__ResultTypeAssignment_0)
3344 { after(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); } 4190 { after(grammarAccess.getFunctionDefinitionAccess().getResultTypeAssignment_0()); }
3345) 4191)
3346; 4192;
3347finally { 4193finally {
3348 restoreStackSize(stackSize); 4194 restoreStackSize(stackSize);
3349} 4195}
3350 4196
3351rule__MetricDefinition__Group__3 4197rule__FunctionDefinition__Group__1
3352 @init { 4198 @init {
3353 int stackSize = keepStackSize(); 4199 int stackSize = keepStackSize();
3354 } 4200 }
3355: 4201:
3356 rule__MetricDefinition__Group__3__Impl 4202 rule__FunctionDefinition__Group__1__Impl
4203 rule__FunctionDefinition__Group__2
3357; 4204;
3358finally { 4205finally {
3359 restoreStackSize(stackSize); 4206 restoreStackSize(stackSize);
3360} 4207}
3361 4208
3362rule__MetricDefinition__Group__3__Impl 4209rule__FunctionDefinition__Group__1__Impl
3363 @init { 4210 @init {
3364 int stackSize = keepStackSize(); 4211 int stackSize = keepStackSize();
3365 } 4212 }
3366: 4213:
3367( 4214(
3368 { before(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); } 4215 { before(grammarAccess.getFunctionDefinitionAccess().getHeadAssignment_1()); }
3369 (rule__MetricDefinition__BodyAssignment_3) 4216 (rule__FunctionDefinition__HeadAssignment_1)
3370 { after(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); } 4217 { after(grammarAccess.getFunctionDefinitionAccess().getHeadAssignment_1()); }
3371) 4218)
3372; 4219;
3373finally { 4220finally {
3374 restoreStackSize(stackSize); 4221 restoreStackSize(stackSize);
3375} 4222}
3376 4223
3377 4224rule__FunctionDefinition__Group__2
3378rule__ExternPredicateDefinition__Group__0
3379 @init { 4225 @init {
3380 int stackSize = keepStackSize(); 4226 int stackSize = keepStackSize();
3381 } 4227 }
3382: 4228:
3383 rule__ExternPredicateDefinition__Group__0__Impl 4229 rule__FunctionDefinition__Group__2__Impl
3384 rule__ExternPredicateDefinition__Group__1 4230 rule__FunctionDefinition__Group__3
3385; 4231;
3386finally { 4232finally {
3387 restoreStackSize(stackSize); 4233 restoreStackSize(stackSize);
3388} 4234}
3389 4235
3390rule__ExternPredicateDefinition__Group__0__Impl 4236rule__FunctionDefinition__Group__2__Impl
3391 @init { 4237 @init {
3392 int stackSize = keepStackSize(); 4238 int stackSize = keepStackSize();
3393 } 4239 }
3394: 4240:
3395( 4241(
3396 { before(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); } 4242 { before(grammarAccess.getFunctionDefinitionAccess().getColonEqualsSignKeyword_2()); }
3397 Extern 4243 ColonEqualsSign
3398 { after(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); } 4244 { after(grammarAccess.getFunctionDefinitionAccess().getColonEqualsSignKeyword_2()); }
3399) 4245)
3400; 4246;
3401finally { 4247finally {
3402 restoreStackSize(stackSize); 4248 restoreStackSize(stackSize);
3403} 4249}
3404 4250
3405rule__ExternPredicateDefinition__Group__1 4251rule__FunctionDefinition__Group__3
3406 @init { 4252 @init {
3407 int stackSize = keepStackSize(); 4253 int stackSize = keepStackSize();
3408 } 4254 }
3409: 4255:
3410 rule__ExternPredicateDefinition__Group__1__Impl 4256 rule__FunctionDefinition__Group__3__Impl
3411 rule__ExternPredicateDefinition__Group__2 4257 rule__FunctionDefinition__Group__4
3412; 4258;
3413finally { 4259finally {
3414 restoreStackSize(stackSize); 4260 restoreStackSize(stackSize);
3415} 4261}
3416 4262
3417rule__ExternPredicateDefinition__Group__1__Impl 4263rule__FunctionDefinition__Group__3__Impl
3418 @init { 4264 @init {
3419 int stackSize = keepStackSize(); 4265 int stackSize = keepStackSize();
3420 } 4266 }
3421: 4267:
3422( 4268(
3423 { before(grammarAccess.getExternPredicateDefinitionAccess().getNameAssignment_1()); } 4269 { before(grammarAccess.getFunctionDefinitionAccess().getBodyAssignment_3()); }
3424 (rule__ExternPredicateDefinition__NameAssignment_1) 4270 (rule__FunctionDefinition__BodyAssignment_3)
3425 { after(grammarAccess.getExternPredicateDefinitionAccess().getNameAssignment_1()); } 4271 { after(grammarAccess.getFunctionDefinitionAccess().getBodyAssignment_3()); }
3426) 4272)
3427; 4273;
3428finally { 4274finally {
3429 restoreStackSize(stackSize); 4275 restoreStackSize(stackSize);
3430} 4276}
3431 4277
3432rule__ExternPredicateDefinition__Group__2 4278rule__FunctionDefinition__Group__4
3433 @init { 4279 @init {
3434 int stackSize = keepStackSize(); 4280 int stackSize = keepStackSize();
3435 } 4281 }
3436: 4282:
3437 rule__ExternPredicateDefinition__Group__2__Impl 4283 rule__FunctionDefinition__Group__4__Impl
3438; 4284;
3439finally { 4285finally {
3440 restoreStackSize(stackSize); 4286 restoreStackSize(stackSize);
3441} 4287}
3442 4288
3443rule__ExternPredicateDefinition__Group__2__Impl 4289rule__FunctionDefinition__Group__4__Impl
3444 @init { 4290 @init {
3445 int stackSize = keepStackSize(); 4291 int stackSize = keepStackSize();
3446 } 4292 }
3447: 4293:
3448( 4294(
3449 { before(grammarAccess.getExternPredicateDefinitionAccess().getArgumentListAssignment_2()); } 4295 { before(grammarAccess.getFunctionDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); }
3450 (rule__ExternPredicateDefinition__ArgumentListAssignment_2) 4296 RULE_FULL_STOP
3451 { after(grammarAccess.getExternPredicateDefinitionAccess().getArgumentListAssignment_2()); } 4297 { after(grammarAccess.getFunctionDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); }
3452) 4298)
3453; 4299;
3454finally { 4300finally {
@@ -3456,107 +4302,134 @@ finally {
3456} 4302}
3457 4303
3458 4304
3459rule__ExternMetricDefinition__Group__0 4305rule__TypeReference__Group__0
3460 @init { 4306 @init {
3461 int stackSize = keepStackSize(); 4307 int stackSize = keepStackSize();
3462 } 4308 }
3463: 4309:
3464 rule__ExternMetricDefinition__Group__0__Impl 4310 rule__TypeReference__Group__0__Impl
3465 rule__ExternMetricDefinition__Group__1 4311 rule__TypeReference__Group__1
3466; 4312;
3467finally { 4313finally {
3468 restoreStackSize(stackSize); 4314 restoreStackSize(stackSize);
3469} 4315}
3470 4316
3471rule__ExternMetricDefinition__Group__0__Impl 4317rule__TypeReference__Group__0__Impl
3472 @init { 4318 @init {
3473 int stackSize = keepStackSize(); 4319 int stackSize = keepStackSize();
3474 } 4320 }
3475: 4321:
3476( 4322(
3477 { before(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); } 4323 { before(grammarAccess.getTypeReferenceAccess().getTypeAssignment_0()); }
3478 Extern 4324 (rule__TypeReference__TypeAssignment_0)
3479 { after(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); } 4325 { after(grammarAccess.getTypeReferenceAccess().getTypeAssignment_0()); }
4326)
4327;
4328finally {
4329 restoreStackSize(stackSize);
4330}
4331
4332rule__TypeReference__Group__1
4333 @init {
4334 int stackSize = keepStackSize();
4335 }
4336:
4337 rule__TypeReference__Group__1__Impl
4338;
4339finally {
4340 restoreStackSize(stackSize);
4341}
4342
4343rule__TypeReference__Group__1__Impl
4344 @init {
4345 int stackSize = keepStackSize();
4346 }
4347:
4348(
4349 { before(grammarAccess.getTypeReferenceAccess().getForceObjectTypeAssignment_1()); }
4350 (rule__TypeReference__ForceObjectTypeAssignment_1)?
4351 { after(grammarAccess.getTypeReferenceAccess().getForceObjectTypeAssignment_1()); }
3480) 4352)
3481; 4353;
3482finally { 4354finally {
3483 restoreStackSize(stackSize); 4355 restoreStackSize(stackSize);
3484} 4356}
3485 4357
3486rule__ExternMetricDefinition__Group__1 4358
4359rule__Attribute__Group__0
3487 @init { 4360 @init {
3488 int stackSize = keepStackSize(); 4361 int stackSize = keepStackSize();
3489 } 4362 }
3490: 4363:
3491 rule__ExternMetricDefinition__Group__1__Impl 4364 rule__Attribute__Group__0__Impl
3492 rule__ExternMetricDefinition__Group__2 4365 rule__Attribute__Group__1
3493; 4366;
3494finally { 4367finally {
3495 restoreStackSize(stackSize); 4368 restoreStackSize(stackSize);
3496} 4369}
3497 4370
3498rule__ExternMetricDefinition__Group__1__Impl 4371rule__Attribute__Group__0__Impl
3499 @init { 4372 @init {
3500 int stackSize = keepStackSize(); 4373 int stackSize = keepStackSize();
3501 } 4374 }
3502: 4375:
3503( 4376(
3504 { before(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); } 4377 { before(grammarAccess.getAttributeAccess().getKindAssignment_0()); }
3505 (rule__ExternMetricDefinition__TypeAssignment_1) 4378 (rule__Attribute__KindAssignment_0)
3506 { after(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); } 4379 { after(grammarAccess.getAttributeAccess().getKindAssignment_0()); }
3507) 4380)
3508; 4381;
3509finally { 4382finally {
3510 restoreStackSize(stackSize); 4383 restoreStackSize(stackSize);
3511} 4384}
3512 4385
3513rule__ExternMetricDefinition__Group__2 4386rule__Attribute__Group__1
3514 @init { 4387 @init {
3515 int stackSize = keepStackSize(); 4388 int stackSize = keepStackSize();
3516 } 4389 }
3517: 4390:
3518 rule__ExternMetricDefinition__Group__2__Impl 4391 rule__Attribute__Group__1__Impl
3519 rule__ExternMetricDefinition__Group__3 4392 rule__Attribute__Group__2
3520; 4393;
3521finally { 4394finally {
3522 restoreStackSize(stackSize); 4395 restoreStackSize(stackSize);
3523} 4396}
3524 4397
3525rule__ExternMetricDefinition__Group__2__Impl 4398rule__Attribute__Group__1__Impl
3526 @init { 4399 @init {
3527 int stackSize = keepStackSize(); 4400 int stackSize = keepStackSize();
3528 } 4401 }
3529: 4402:
3530( 4403(
3531 { before(grammarAccess.getExternMetricDefinitionAccess().getNameAssignment_2()); } 4404 { before(grammarAccess.getAttributeAccess().getTargetAssignment_1()); }
3532 (rule__ExternMetricDefinition__NameAssignment_2) 4405 (rule__Attribute__TargetAssignment_1)
3533 { after(grammarAccess.getExternMetricDefinitionAccess().getNameAssignment_2()); } 4406 { after(grammarAccess.getAttributeAccess().getTargetAssignment_1()); }
3534) 4407)
3535; 4408;
3536finally { 4409finally {
3537 restoreStackSize(stackSize); 4410 restoreStackSize(stackSize);
3538} 4411}
3539 4412
3540rule__ExternMetricDefinition__Group__3 4413rule__Attribute__Group__2
3541 @init { 4414 @init {
3542 int stackSize = keepStackSize(); 4415 int stackSize = keepStackSize();
3543 } 4416 }
3544: 4417:
3545 rule__ExternMetricDefinition__Group__3__Impl 4418 rule__Attribute__Group__2__Impl
3546; 4419;
3547finally { 4420finally {
3548 restoreStackSize(stackSize); 4421 restoreStackSize(stackSize);
3549} 4422}
3550 4423
3551rule__ExternMetricDefinition__Group__3__Impl 4424rule__Attribute__Group__2__Impl
3552 @init { 4425 @init {
3553 int stackSize = keepStackSize(); 4426 int stackSize = keepStackSize();
3554 } 4427 }
3555: 4428:
3556( 4429(
3557 { before(grammarAccess.getExternMetricDefinitionAccess().getArgumentListAssignment_3()); } 4430 { before(grammarAccess.getAttributeAccess().getFULL_STOPTerminalRuleCall_2()); }
3558 (rule__ExternMetricDefinition__ArgumentListAssignment_3) 4431 RULE_FULL_STOP
3559 { after(grammarAccess.getExternMetricDefinitionAccess().getArgumentListAssignment_3()); } 4432 { after(grammarAccess.getAttributeAccess().getFULL_STOPTerminalRuleCall_2()); }
3560) 4433)
3561; 4434;
3562finally { 4435finally {
@@ -3564,431 +4437,485 @@ finally {
3564} 4437}
3565 4438
3566 4439
3567rule__ExternAggregatorDefinition__Group__0 4440rule__ExternPredicateDeclaration__Group__0
3568 @init { 4441 @init {
3569 int stackSize = keepStackSize(); 4442 int stackSize = keepStackSize();
3570 } 4443 }
3571: 4444:
3572 rule__ExternAggregatorDefinition__Group__0__Impl 4445 rule__ExternPredicateDeclaration__Group__0__Impl
3573 rule__ExternAggregatorDefinition__Group__1 4446 rule__ExternPredicateDeclaration__Group__1
3574; 4447;
3575finally { 4448finally {
3576 restoreStackSize(stackSize); 4449 restoreStackSize(stackSize);
3577} 4450}
3578 4451
3579rule__ExternAggregatorDefinition__Group__0__Impl 4452rule__ExternPredicateDeclaration__Group__0__Impl
3580 @init { 4453 @init {
3581 int stackSize = keepStackSize(); 4454 int stackSize = keepStackSize();
3582 } 4455 }
3583: 4456:
3584( 4457(
3585 { before(grammarAccess.getExternAggregatorDefinitionAccess().getExternKeyword_0()); } 4458 { before(grammarAccess.getExternPredicateDeclarationAccess().getExternKeyword_0()); }
3586 Extern 4459 Extern
3587 { after(grammarAccess.getExternAggregatorDefinitionAccess().getExternKeyword_0()); } 4460 { after(grammarAccess.getExternPredicateDeclarationAccess().getExternKeyword_0()); }
3588) 4461)
3589; 4462;
3590finally { 4463finally {
3591 restoreStackSize(stackSize); 4464 restoreStackSize(stackSize);
3592} 4465}
3593 4466
3594rule__ExternAggregatorDefinition__Group__1 4467rule__ExternPredicateDeclaration__Group__1
3595 @init { 4468 @init {
3596 int stackSize = keepStackSize(); 4469 int stackSize = keepStackSize();
3597 } 4470 }
3598: 4471:
3599 rule__ExternAggregatorDefinition__Group__1__Impl 4472 rule__ExternPredicateDeclaration__Group__1__Impl
3600 rule__ExternAggregatorDefinition__Group__2 4473 rule__ExternPredicateDeclaration__Group__2
3601; 4474;
3602finally { 4475finally {
3603 restoreStackSize(stackSize); 4476 restoreStackSize(stackSize);
3604} 4477}
3605 4478
3606rule__ExternAggregatorDefinition__Group__1__Impl 4479rule__ExternPredicateDeclaration__Group__1__Impl
3607 @init { 4480 @init {
3608 int stackSize = keepStackSize(); 4481 int stackSize = keepStackSize();
3609 } 4482 }
3610: 4483:
3611( 4484(
3612 { before(grammarAccess.getExternAggregatorDefinitionAccess().getTypeAssignment_1()); } 4485 { before(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); }
3613 (rule__ExternAggregatorDefinition__TypeAssignment_1) 4486 (rule__ExternPredicateDeclaration__UnorderedGroup_1)
3614 { after(grammarAccess.getExternAggregatorDefinitionAccess().getTypeAssignment_1()); } 4487 { after(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); }
3615) 4488)
3616; 4489;
3617finally { 4490finally {
3618 restoreStackSize(stackSize); 4491 restoreStackSize(stackSize);
3619} 4492}
3620 4493
3621rule__ExternAggregatorDefinition__Group__2 4494rule__ExternPredicateDeclaration__Group__2
3622 @init { 4495 @init {
3623 int stackSize = keepStackSize(); 4496 int stackSize = keepStackSize();
3624 } 4497 }
3625: 4498:
3626 rule__ExternAggregatorDefinition__Group__2__Impl 4499 rule__ExternPredicateDeclaration__Group__2__Impl
3627 rule__ExternAggregatorDefinition__Group__3 4500 rule__ExternPredicateDeclaration__Group__3
3628; 4501;
3629finally { 4502finally {
3630 restoreStackSize(stackSize); 4503 restoreStackSize(stackSize);
3631} 4504}
3632 4505
3633rule__ExternAggregatorDefinition__Group__2__Impl 4506rule__ExternPredicateDeclaration__Group__2__Impl
3634 @init { 4507 @init {
3635 int stackSize = keepStackSize(); 4508 int stackSize = keepStackSize();
3636 } 4509 }
3637: 4510:
3638( 4511(
3639 { before(grammarAccess.getExternAggregatorDefinitionAccess().getNameAssignment_2()); } 4512 { before(grammarAccess.getExternPredicateDeclarationAccess().getNameAssignment_2()); }
3640 (rule__ExternAggregatorDefinition__NameAssignment_2) 4513 (rule__ExternPredicateDeclaration__NameAssignment_2)
3641 { after(grammarAccess.getExternAggregatorDefinitionAccess().getNameAssignment_2()); } 4514 { after(grammarAccess.getExternPredicateDeclarationAccess().getNameAssignment_2()); }
3642) 4515)
3643; 4516;
3644finally { 4517finally {
3645 restoreStackSize(stackSize); 4518 restoreStackSize(stackSize);
3646} 4519}
3647 4520
3648rule__ExternAggregatorDefinition__Group__3 4521rule__ExternPredicateDeclaration__Group__3
3649 @init { 4522 @init {
3650 int stackSize = keepStackSize(); 4523 int stackSize = keepStackSize();
3651 } 4524 }
3652: 4525:
3653 rule__ExternAggregatorDefinition__Group__3__Impl 4526 rule__ExternPredicateDeclaration__Group__3__Impl
3654 rule__ExternAggregatorDefinition__Group__4 4527 rule__ExternPredicateDeclaration__Group__4
3655; 4528;
3656finally { 4529finally {
3657 restoreStackSize(stackSize); 4530 restoreStackSize(stackSize);
3658} 4531}
3659 4532
3660rule__ExternAggregatorDefinition__Group__3__Impl 4533rule__ExternPredicateDeclaration__Group__3__Impl
3661 @init { 4534 @init {
3662 int stackSize = keepStackSize(); 4535 int stackSize = keepStackSize();
3663 } 4536 }
3664: 4537:
3665( 4538(
3666 { before(grammarAccess.getExternAggregatorDefinitionAccess().getLeftCurlyBracketKeyword_3()); } 4539 { before(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListAssignment_3()); }
3667 LeftCurlyBracket 4540 (rule__ExternPredicateDeclaration__ArgumentListAssignment_3)
3668 { after(grammarAccess.getExternAggregatorDefinitionAccess().getLeftCurlyBracketKeyword_3()); } 4541 { after(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListAssignment_3()); }
3669) 4542)
3670; 4543;
3671finally { 4544finally {
3672 restoreStackSize(stackSize); 4545 restoreStackSize(stackSize);
3673} 4546}
3674 4547
3675rule__ExternAggregatorDefinition__Group__4 4548rule__ExternPredicateDeclaration__Group__4
3676 @init { 4549 @init {
3677 int stackSize = keepStackSize(); 4550 int stackSize = keepStackSize();
3678 } 4551 }
3679: 4552:
3680 rule__ExternAggregatorDefinition__Group__4__Impl 4553 rule__ExternPredicateDeclaration__Group__4__Impl
3681 rule__ExternAggregatorDefinition__Group__5
3682; 4554;
3683finally { 4555finally {
3684 restoreStackSize(stackSize); 4556 restoreStackSize(stackSize);
3685} 4557}
3686 4558
3687rule__ExternAggregatorDefinition__Group__4__Impl 4559rule__ExternPredicateDeclaration__Group__4__Impl
3688 @init { 4560 @init {
3689 int stackSize = keepStackSize(); 4561 int stackSize = keepStackSize();
3690 } 4562 }
3691: 4563:
3692( 4564(
3693 { before(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeAssignment_4()); } 4565 { before(grammarAccess.getExternPredicateDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); }
3694 (rule__ExternAggregatorDefinition__InputTypeAssignment_4) 4566 RULE_FULL_STOP
3695 { after(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeAssignment_4()); } 4567 { after(grammarAccess.getExternPredicateDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); }
3696) 4568)
3697; 4569;
3698finally { 4570finally {
3699 restoreStackSize(stackSize); 4571 restoreStackSize(stackSize);
3700} 4572}
3701 4573
3702rule__ExternAggregatorDefinition__Group__5 4574
4575rule__ExternFunctionDeclaration__Group__0
3703 @init { 4576 @init {
3704 int stackSize = keepStackSize(); 4577 int stackSize = keepStackSize();
3705 } 4578 }
3706: 4579:
3707 rule__ExternAggregatorDefinition__Group__5__Impl 4580 rule__ExternFunctionDeclaration__Group__0__Impl
3708 rule__ExternAggregatorDefinition__Group__6 4581 rule__ExternFunctionDeclaration__Group__1
3709; 4582;
3710finally { 4583finally {
3711 restoreStackSize(stackSize); 4584 restoreStackSize(stackSize);
3712} 4585}
3713 4586
3714rule__ExternAggregatorDefinition__Group__5__Impl 4587rule__ExternFunctionDeclaration__Group__0__Impl
3715 @init { 4588 @init {
3716 int stackSize = keepStackSize(); 4589 int stackSize = keepStackSize();
3717 } 4590 }
3718: 4591:
3719( 4592(
3720 { before(grammarAccess.getExternAggregatorDefinitionAccess().getFullStopFullStopFullStopKeyword_5()); } 4593 { before(grammarAccess.getExternFunctionDeclarationAccess().getExternKeyword_0()); }
3721 FullStopFullStopFullStop 4594 Extern
3722 { after(grammarAccess.getExternAggregatorDefinitionAccess().getFullStopFullStopFullStopKeyword_5()); } 4595 { after(grammarAccess.getExternFunctionDeclarationAccess().getExternKeyword_0()); }
3723) 4596)
3724; 4597;
3725finally { 4598finally {
3726 restoreStackSize(stackSize); 4599 restoreStackSize(stackSize);
3727} 4600}
3728 4601
3729rule__ExternAggregatorDefinition__Group__6 4602rule__ExternFunctionDeclaration__Group__1
3730 @init { 4603 @init {
3731 int stackSize = keepStackSize(); 4604 int stackSize = keepStackSize();
3732 } 4605 }
3733: 4606:
3734 rule__ExternAggregatorDefinition__Group__6__Impl 4607 rule__ExternFunctionDeclaration__Group__1__Impl
4608 rule__ExternFunctionDeclaration__Group__2
3735; 4609;
3736finally { 4610finally {
3737 restoreStackSize(stackSize); 4611 restoreStackSize(stackSize);
3738} 4612}
3739 4613
3740rule__ExternAggregatorDefinition__Group__6__Impl 4614rule__ExternFunctionDeclaration__Group__1__Impl
3741 @init { 4615 @init {
3742 int stackSize = keepStackSize(); 4616 int stackSize = keepStackSize();
3743 } 4617 }
3744: 4618:
3745( 4619(
3746 { before(grammarAccess.getExternAggregatorDefinitionAccess().getRightCurlyBracketKeyword_6()); } 4620 { before(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeAssignment_1()); }
3747 RightCurlyBracket 4621 (rule__ExternFunctionDeclaration__ResultTypeAssignment_1)
3748 { after(grammarAccess.getExternAggregatorDefinitionAccess().getRightCurlyBracketKeyword_6()); } 4622 { after(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeAssignment_1()); }
3749) 4623)
3750; 4624;
3751finally { 4625finally {
3752 restoreStackSize(stackSize); 4626 restoreStackSize(stackSize);
3753} 4627}
3754 4628
3755 4629rule__ExternFunctionDeclaration__Group__2
3756rule__ExternDatatypeDefinition__Group__0
3757 @init { 4630 @init {
3758 int stackSize = keepStackSize(); 4631 int stackSize = keepStackSize();
3759 } 4632 }
3760: 4633:
3761 rule__ExternDatatypeDefinition__Group__0__Impl 4634 rule__ExternFunctionDeclaration__Group__2__Impl
3762 rule__ExternDatatypeDefinition__Group__1 4635 rule__ExternFunctionDeclaration__Group__3
3763; 4636;
3764finally { 4637finally {
3765 restoreStackSize(stackSize); 4638 restoreStackSize(stackSize);
3766} 4639}
3767 4640
3768rule__ExternDatatypeDefinition__Group__0__Impl 4641rule__ExternFunctionDeclaration__Group__2__Impl
3769 @init { 4642 @init {
3770 int stackSize = keepStackSize(); 4643 int stackSize = keepStackSize();
3771 } 4644 }
3772: 4645:
3773( 4646(
3774 { before(grammarAccess.getExternDatatypeDefinitionAccess().getExternKeyword_0()); } 4647 { before(grammarAccess.getExternFunctionDeclarationAccess().getNameAssignment_2()); }
3775 Extern 4648 (rule__ExternFunctionDeclaration__NameAssignment_2)
3776 { after(grammarAccess.getExternDatatypeDefinitionAccess().getExternKeyword_0()); } 4649 { after(grammarAccess.getExternFunctionDeclarationAccess().getNameAssignment_2()); }
3777) 4650)
3778; 4651;
3779finally { 4652finally {
3780 restoreStackSize(stackSize); 4653 restoreStackSize(stackSize);
3781} 4654}
3782 4655
3783rule__ExternDatatypeDefinition__Group__1 4656rule__ExternFunctionDeclaration__Group__3
3784 @init { 4657 @init {
3785 int stackSize = keepStackSize(); 4658 int stackSize = keepStackSize();
3786 } 4659 }
3787: 4660:
3788 rule__ExternDatatypeDefinition__Group__1__Impl 4661 rule__ExternFunctionDeclaration__Group__3__Impl
3789 rule__ExternDatatypeDefinition__Group__2 4662 rule__ExternFunctionDeclaration__Group__4
3790; 4663;
3791finally { 4664finally {
3792 restoreStackSize(stackSize); 4665 restoreStackSize(stackSize);
3793} 4666}
3794 4667
3795rule__ExternDatatypeDefinition__Group__1__Impl 4668rule__ExternFunctionDeclaration__Group__3__Impl
3796 @init { 4669 @init {
3797 int stackSize = keepStackSize(); 4670 int stackSize = keepStackSize();
3798 } 4671 }
3799: 4672:
3800( 4673(
3801 { before(grammarAccess.getExternDatatypeDefinitionAccess().getDatatypeKeyword_1()); } 4674 { before(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListAssignment_3()); }
3802 Datatype 4675 (rule__ExternFunctionDeclaration__ArgumentListAssignment_3)
3803 { after(grammarAccess.getExternDatatypeDefinitionAccess().getDatatypeKeyword_1()); } 4676 { after(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListAssignment_3()); }
3804) 4677)
3805; 4678;
3806finally { 4679finally {
3807 restoreStackSize(stackSize); 4680 restoreStackSize(stackSize);
3808} 4681}
3809 4682
3810rule__ExternDatatypeDefinition__Group__2 4683rule__ExternFunctionDeclaration__Group__4
3811 @init { 4684 @init {
3812 int stackSize = keepStackSize(); 4685 int stackSize = keepStackSize();
3813 } 4686 }
3814: 4687:
3815 rule__ExternDatatypeDefinition__Group__2__Impl 4688 rule__ExternFunctionDeclaration__Group__4__Impl
3816 rule__ExternDatatypeDefinition__Group__3
3817; 4689;
3818finally { 4690finally {
3819 restoreStackSize(stackSize); 4691 restoreStackSize(stackSize);
3820} 4692}
3821 4693
3822rule__ExternDatatypeDefinition__Group__2__Impl 4694rule__ExternFunctionDeclaration__Group__4__Impl
3823 @init { 4695 @init {
3824 int stackSize = keepStackSize(); 4696 int stackSize = keepStackSize();
3825 } 4697 }
3826: 4698:
3827( 4699(
3828 { before(grammarAccess.getExternDatatypeDefinitionAccess().getNameAssignment_2()); } 4700 { before(grammarAccess.getExternFunctionDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); }
3829 (rule__ExternDatatypeDefinition__NameAssignment_2) 4701 RULE_FULL_STOP
3830 { after(grammarAccess.getExternDatatypeDefinitionAccess().getNameAssignment_2()); } 4702 { after(grammarAccess.getExternFunctionDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); }
3831) 4703)
3832; 4704;
3833finally { 4705finally {
3834 restoreStackSize(stackSize); 4706 restoreStackSize(stackSize);
3835} 4707}
3836 4708
3837rule__ExternDatatypeDefinition__Group__3 4709
4710rule__ExternAggregationOperatorDeclaration__Group__0
3838 @init { 4711 @init {
3839 int stackSize = keepStackSize(); 4712 int stackSize = keepStackSize();
3840 } 4713 }
3841: 4714:
3842 rule__ExternDatatypeDefinition__Group__3__Impl 4715 rule__ExternAggregationOperatorDeclaration__Group__0__Impl
4716 rule__ExternAggregationOperatorDeclaration__Group__1
3843; 4717;
3844finally { 4718finally {
3845 restoreStackSize(stackSize); 4719 restoreStackSize(stackSize);
3846} 4720}
3847 4721
3848rule__ExternDatatypeDefinition__Group__3__Impl 4722rule__ExternAggregationOperatorDeclaration__Group__0__Impl
3849 @init { 4723 @init {
3850 int stackSize = keepStackSize(); 4724 int stackSize = keepStackSize();
3851 } 4725 }
3852: 4726:
3853( 4727(
3854 { before(grammarAccess.getExternDatatypeDefinitionAccess().getGroup_3()); } 4728 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getExternKeyword_0()); }
3855 (rule__ExternDatatypeDefinition__Group_3__0) 4729 Extern
3856 { after(grammarAccess.getExternDatatypeDefinitionAccess().getGroup_3()); } 4730 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getExternKeyword_0()); }
3857) 4731)
3858; 4732;
3859finally { 4733finally {
3860 restoreStackSize(stackSize); 4734 restoreStackSize(stackSize);
3861} 4735}
3862 4736
4737rule__ExternAggregationOperatorDeclaration__Group__1
4738 @init {
4739 int stackSize = keepStackSize();
4740 }
4741:
4742 rule__ExternAggregationOperatorDeclaration__Group__1__Impl
4743 rule__ExternAggregationOperatorDeclaration__Group__2
4744;
4745finally {
4746 restoreStackSize(stackSize);
4747}
4748
4749rule__ExternAggregationOperatorDeclaration__Group__1__Impl
4750 @init {
4751 int stackSize = keepStackSize();
4752 }
4753:
4754(
4755 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeAssignment_1()); }
4756 (rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1)
4757 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeAssignment_1()); }
4758)
4759;
4760finally {
4761 restoreStackSize(stackSize);
4762}
3863 4763
3864rule__ExternDatatypeDefinition__Group_3__0 4764rule__ExternAggregationOperatorDeclaration__Group__2
3865 @init { 4765 @init {
3866 int stackSize = keepStackSize(); 4766 int stackSize = keepStackSize();
3867 } 4767 }
3868: 4768:
3869 rule__ExternDatatypeDefinition__Group_3__0__Impl 4769 rule__ExternAggregationOperatorDeclaration__Group__2__Impl
3870 rule__ExternDatatypeDefinition__Group_3__1 4770 rule__ExternAggregationOperatorDeclaration__Group__3
3871; 4771;
3872finally { 4772finally {
3873 restoreStackSize(stackSize); 4773 restoreStackSize(stackSize);
3874} 4774}
3875 4775
3876rule__ExternDatatypeDefinition__Group_3__0__Impl 4776rule__ExternAggregationOperatorDeclaration__Group__2__Impl
3877 @init { 4777 @init {
3878 int stackSize = keepStackSize(); 4778 int stackSize = keepStackSize();
3879 } 4779 }
3880: 4780:
3881( 4781(
3882 { before(grammarAccess.getExternDatatypeDefinitionAccess().getExtendsKeyword_3_0()); } 4782 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameAssignment_2()); }
3883 Extends 4783 (rule__ExternAggregationOperatorDeclaration__NameAssignment_2)
3884 { after(grammarAccess.getExternDatatypeDefinitionAccess().getExtendsKeyword_3_0()); } 4784 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameAssignment_2()); }
3885) 4785)
3886; 4786;
3887finally { 4787finally {
3888 restoreStackSize(stackSize); 4788 restoreStackSize(stackSize);
3889} 4789}
3890 4790
3891rule__ExternDatatypeDefinition__Group_3__1 4791rule__ExternAggregationOperatorDeclaration__Group__3
3892 @init { 4792 @init {
3893 int stackSize = keepStackSize(); 4793 int stackSize = keepStackSize();
3894 } 4794 }
3895: 4795:
3896 rule__ExternDatatypeDefinition__Group_3__1__Impl 4796 rule__ExternAggregationOperatorDeclaration__Group__3__Impl
3897 rule__ExternDatatypeDefinition__Group_3__2 4797 rule__ExternAggregationOperatorDeclaration__Group__4
3898; 4798;
3899finally { 4799finally {
3900 restoreStackSize(stackSize); 4800 restoreStackSize(stackSize);
3901} 4801}
3902 4802
3903rule__ExternDatatypeDefinition__Group_3__1__Impl 4803rule__ExternAggregationOperatorDeclaration__Group__3__Impl
3904 @init { 4804 @init {
3905 int stackSize = keepStackSize(); 4805 int stackSize = keepStackSize();
3906 } 4806 }
3907: 4807:
3908( 4808(
3909 { before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesAssignment_3_1()); } 4809 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getLeftCurlyBracketKeyword_3()); }
3910 (rule__ExternDatatypeDefinition__SupertypesAssignment_3_1) 4810 LeftCurlyBracket
3911 { after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesAssignment_3_1()); } 4811 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getLeftCurlyBracketKeyword_3()); }
3912) 4812)
3913; 4813;
3914finally { 4814finally {
3915 restoreStackSize(stackSize); 4815 restoreStackSize(stackSize);
3916} 4816}
3917 4817
3918rule__ExternDatatypeDefinition__Group_3__2 4818rule__ExternAggregationOperatorDeclaration__Group__4
3919 @init { 4819 @init {
3920 int stackSize = keepStackSize(); 4820 int stackSize = keepStackSize();
3921 } 4821 }
3922: 4822:
3923 rule__ExternDatatypeDefinition__Group_3__2__Impl 4823 rule__ExternAggregationOperatorDeclaration__Group__4__Impl
4824 rule__ExternAggregationOperatorDeclaration__Group__5
3924; 4825;
3925finally { 4826finally {
3926 restoreStackSize(stackSize); 4827 restoreStackSize(stackSize);
3927} 4828}
3928 4829
3929rule__ExternDatatypeDefinition__Group_3__2__Impl 4830rule__ExternAggregationOperatorDeclaration__Group__4__Impl
3930 @init { 4831 @init {
3931 int stackSize = keepStackSize(); 4832 int stackSize = keepStackSize();
3932 } 4833 }
3933: 4834:
3934( 4835(
3935 { before(grammarAccess.getExternDatatypeDefinitionAccess().getGroup_3_2()); } 4836 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeAssignment_4()); }
3936 (rule__ExternDatatypeDefinition__Group_3_2__0)* 4837 (rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4)
3937 { after(grammarAccess.getExternDatatypeDefinitionAccess().getGroup_3_2()); } 4838 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeAssignment_4()); }
3938) 4839)
3939; 4840;
3940finally { 4841finally {
3941 restoreStackSize(stackSize); 4842 restoreStackSize(stackSize);
3942} 4843}
3943 4844
4845rule__ExternAggregationOperatorDeclaration__Group__5
4846 @init {
4847 int stackSize = keepStackSize();
4848 }
4849:
4850 rule__ExternAggregationOperatorDeclaration__Group__5__Impl
4851 rule__ExternAggregationOperatorDeclaration__Group__6
4852;
4853finally {
4854 restoreStackSize(stackSize);
4855}
3944 4856
3945rule__ExternDatatypeDefinition__Group_3_2__0 4857rule__ExternAggregationOperatorDeclaration__Group__5__Impl
3946 @init { 4858 @init {
3947 int stackSize = keepStackSize(); 4859 int stackSize = keepStackSize();
3948 } 4860 }
3949: 4861:
3950 rule__ExternDatatypeDefinition__Group_3_2__0__Impl 4862(
3951 rule__ExternDatatypeDefinition__Group_3_2__1 4863 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFullStopFullStopFullStopKeyword_5()); }
4864 FullStopFullStopFullStop
4865 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFullStopFullStopFullStopKeyword_5()); }
4866)
3952; 4867;
3953finally { 4868finally {
3954 restoreStackSize(stackSize); 4869 restoreStackSize(stackSize);
3955} 4870}
3956 4871
3957rule__ExternDatatypeDefinition__Group_3_2__0__Impl 4872rule__ExternAggregationOperatorDeclaration__Group__6
4873 @init {
4874 int stackSize = keepStackSize();
4875 }
4876:
4877 rule__ExternAggregationOperatorDeclaration__Group__6__Impl
4878 rule__ExternAggregationOperatorDeclaration__Group__7
4879;
4880finally {
4881 restoreStackSize(stackSize);
4882}
4883
4884rule__ExternAggregationOperatorDeclaration__Group__6__Impl
3958 @init { 4885 @init {
3959 int stackSize = keepStackSize(); 4886 int stackSize = keepStackSize();
3960 } 4887 }
3961: 4888:
3962( 4889(
3963 { before(grammarAccess.getExternDatatypeDefinitionAccess().getCommaKeyword_3_2_0()); } 4890 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getRightCurlyBracketKeyword_6()); }
3964 Comma 4891 RightCurlyBracket
3965 { after(grammarAccess.getExternDatatypeDefinitionAccess().getCommaKeyword_3_2_0()); } 4892 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getRightCurlyBracketKeyword_6()); }
3966) 4893)
3967; 4894;
3968finally { 4895finally {
3969 restoreStackSize(stackSize); 4896 restoreStackSize(stackSize);
3970} 4897}
3971 4898
3972rule__ExternDatatypeDefinition__Group_3_2__1 4899rule__ExternAggregationOperatorDeclaration__Group__7
3973 @init { 4900 @init {
3974 int stackSize = keepStackSize(); 4901 int stackSize = keepStackSize();
3975 } 4902 }
3976: 4903:
3977 rule__ExternDatatypeDefinition__Group_3_2__1__Impl 4904 rule__ExternAggregationOperatorDeclaration__Group__7__Impl
3978; 4905;
3979finally { 4906finally {
3980 restoreStackSize(stackSize); 4907 restoreStackSize(stackSize);
3981} 4908}
3982 4909
3983rule__ExternDatatypeDefinition__Group_3_2__1__Impl 4910rule__ExternAggregationOperatorDeclaration__Group__7__Impl
3984 @init { 4911 @init {
3985 int stackSize = keepStackSize(); 4912 int stackSize = keepStackSize();
3986 } 4913 }
3987: 4914:
3988( 4915(
3989 { before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesAssignment_3_2_1()); } 4916 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFULL_STOPTerminalRuleCall_7()); }
3990 (rule__ExternDatatypeDefinition__SupertypesAssignment_3_2_1) 4917 RULE_FULL_STOP
3991 { after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesAssignment_3_2_1()); } 4918 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFULL_STOPTerminalRuleCall_7()); }
3992) 4919)
3993; 4920;
3994finally { 4921finally {
@@ -3996,215 +4923,242 @@ finally {
3996} 4923}
3997 4924
3998 4925
3999rule__Variable__Group__0 4926rule__ExternDatatypeDeclaration__Group__0
4000 @init { 4927 @init {
4001 int stackSize = keepStackSize(); 4928 int stackSize = keepStackSize();
4002 } 4929 }
4003: 4930:
4004 rule__Variable__Group__0__Impl 4931 rule__ExternDatatypeDeclaration__Group__0__Impl
4005 rule__Variable__Group__1 4932 rule__ExternDatatypeDeclaration__Group__1
4006; 4933;
4007finally { 4934finally {
4008 restoreStackSize(stackSize); 4935 restoreStackSize(stackSize);
4009} 4936}
4010 4937
4011rule__Variable__Group__0__Impl 4938rule__ExternDatatypeDeclaration__Group__0__Impl
4012 @init { 4939 @init {
4013 int stackSize = keepStackSize(); 4940 int stackSize = keepStackSize();
4014 } 4941 }
4015: 4942:
4016( 4943(
4017 { before(grammarAccess.getVariableAccess().getTypeAssignment_0()); } 4944 { before(grammarAccess.getExternDatatypeDeclarationAccess().getExternKeyword_0()); }
4018 (rule__Variable__TypeAssignment_0)? 4945 Extern
4019 { after(grammarAccess.getVariableAccess().getTypeAssignment_0()); } 4946 { after(grammarAccess.getExternDatatypeDeclarationAccess().getExternKeyword_0()); }
4020) 4947)
4021; 4948;
4022finally { 4949finally {
4023 restoreStackSize(stackSize); 4950 restoreStackSize(stackSize);
4024} 4951}
4025 4952
4026rule__Variable__Group__1 4953rule__ExternDatatypeDeclaration__Group__1
4027 @init { 4954 @init {
4028 int stackSize = keepStackSize(); 4955 int stackSize = keepStackSize();
4029 } 4956 }
4030: 4957:
4031 rule__Variable__Group__1__Impl 4958 rule__ExternDatatypeDeclaration__Group__1__Impl
4959 rule__ExternDatatypeDeclaration__Group__2
4032; 4960;
4033finally { 4961finally {
4034 restoreStackSize(stackSize); 4962 restoreStackSize(stackSize);
4035} 4963}
4036 4964
4037rule__Variable__Group__1__Impl 4965rule__ExternDatatypeDeclaration__Group__1__Impl
4038 @init { 4966 @init {
4039 int stackSize = keepStackSize(); 4967 int stackSize = keepStackSize();
4040 } 4968 }
4041: 4969:
4042( 4970(
4043 { before(grammarAccess.getVariableAccess().getNameAssignment_1()); } 4971 { before(grammarAccess.getExternDatatypeDeclarationAccess().getDatatypeKeyword_1()); }
4044 (rule__Variable__NameAssignment_1) 4972 Datatype
4045 { after(grammarAccess.getVariableAccess().getNameAssignment_1()); } 4973 { after(grammarAccess.getExternDatatypeDeclarationAccess().getDatatypeKeyword_1()); }
4046) 4974)
4047; 4975;
4048finally { 4976finally {
4049 restoreStackSize(stackSize); 4977 restoreStackSize(stackSize);
4050} 4978}
4051 4979
4980rule__ExternDatatypeDeclaration__Group__2
4981 @init {
4982 int stackSize = keepStackSize();
4983 }
4984:
4985 rule__ExternDatatypeDeclaration__Group__2__Impl
4986 rule__ExternDatatypeDeclaration__Group__3
4987;
4988finally {
4989 restoreStackSize(stackSize);
4990}
4052 4991
4053rule__IfElse__Group__0 4992rule__ExternDatatypeDeclaration__Group__2__Impl
4054 @init { 4993 @init {
4055 int stackSize = keepStackSize(); 4994 int stackSize = keepStackSize();
4056 } 4995 }
4057: 4996:
4058 rule__IfElse__Group__0__Impl 4997(
4059 rule__IfElse__Group__1 4998 { before(grammarAccess.getExternDatatypeDeclarationAccess().getNameAssignment_2()); }
4999 (rule__ExternDatatypeDeclaration__NameAssignment_2)
5000 { after(grammarAccess.getExternDatatypeDeclarationAccess().getNameAssignment_2()); }
5001)
4060; 5002;
4061finally { 5003finally {
4062 restoreStackSize(stackSize); 5004 restoreStackSize(stackSize);
4063} 5005}
4064 5006
4065rule__IfElse__Group__0__Impl 5007rule__ExternDatatypeDeclaration__Group__3
5008 @init {
5009 int stackSize = keepStackSize();
5010 }
5011:
5012 rule__ExternDatatypeDeclaration__Group__3__Impl
5013;
5014finally {
5015 restoreStackSize(stackSize);
5016}
5017
5018rule__ExternDatatypeDeclaration__Group__3__Impl
4066 @init { 5019 @init {
4067 int stackSize = keepStackSize(); 5020 int stackSize = keepStackSize();
4068 } 5021 }
4069: 5022:
4070( 5023(
4071 { before(grammarAccess.getIfElseAccess().getIfKeyword_0()); } 5024 { before(grammarAccess.getExternDatatypeDeclarationAccess().getFULL_STOPTerminalRuleCall_3()); }
4072 If 5025 RULE_FULL_STOP
4073 { after(grammarAccess.getIfElseAccess().getIfKeyword_0()); } 5026 { after(grammarAccess.getExternDatatypeDeclarationAccess().getFULL_STOPTerminalRuleCall_3()); }
4074) 5027)
4075; 5028;
4076finally { 5029finally {
4077 restoreStackSize(stackSize); 5030 restoreStackSize(stackSize);
4078} 5031}
4079 5032
4080rule__IfElse__Group__1 5033
5034rule__Expression__Group_2__0
4081 @init { 5035 @init {
4082 int stackSize = keepStackSize(); 5036 int stackSize = keepStackSize();
4083 } 5037 }
4084: 5038:
4085 rule__IfElse__Group__1__Impl 5039 rule__Expression__Group_2__0__Impl
4086 rule__IfElse__Group__2 5040 rule__Expression__Group_2__1
4087; 5041;
4088finally { 5042finally {
4089 restoreStackSize(stackSize); 5043 restoreStackSize(stackSize);
4090} 5044}
4091 5045
4092rule__IfElse__Group__1__Impl 5046rule__Expression__Group_2__0__Impl
4093 @init { 5047 @init {
4094 int stackSize = keepStackSize(); 5048 int stackSize = keepStackSize();
4095 } 5049 }
4096: 5050:
4097( 5051(
4098 { before(grammarAccess.getIfElseAccess().getConditionAssignment_1()); } 5052 { before(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_2_0()); }
4099 (rule__IfElse__ConditionAssignment_1) 5053 ruleDisjunctiveExpression
4100 { after(grammarAccess.getIfElseAccess().getConditionAssignment_1()); } 5054 { after(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_2_0()); }
4101) 5055)
4102; 5056;
4103finally { 5057finally {
4104 restoreStackSize(stackSize); 5058 restoreStackSize(stackSize);
4105} 5059}
4106 5060
4107rule__IfElse__Group__2 5061rule__Expression__Group_2__1
4108 @init { 5062 @init {
4109 int stackSize = keepStackSize(); 5063 int stackSize = keepStackSize();
4110 } 5064 }
4111: 5065:
4112 rule__IfElse__Group__2__Impl 5066 rule__Expression__Group_2__1__Impl
4113 rule__IfElse__Group__3
4114; 5067;
4115finally { 5068finally {
4116 restoreStackSize(stackSize); 5069 restoreStackSize(stackSize);
4117} 5070}
4118 5071
4119rule__IfElse__Group__2__Impl 5072rule__Expression__Group_2__1__Impl
4120 @init { 5073 @init {
4121 int stackSize = keepStackSize(); 5074 int stackSize = keepStackSize();
4122 } 5075 }
4123: 5076:
4124( 5077(
4125 { before(grammarAccess.getIfElseAccess().getThenKeyword_2()); } 5078 { before(grammarAccess.getExpressionAccess().getGroup_2_1()); }
4126 Then 5079 (rule__Expression__Group_2_1__0)?
4127 { after(grammarAccess.getIfElseAccess().getThenKeyword_2()); } 5080 { after(grammarAccess.getExpressionAccess().getGroup_2_1()); }
4128) 5081)
4129; 5082;
4130finally { 5083finally {
4131 restoreStackSize(stackSize); 5084 restoreStackSize(stackSize);
4132} 5085}
4133 5086
4134rule__IfElse__Group__3 5087
5088rule__Expression__Group_2_1__0
4135 @init { 5089 @init {
4136 int stackSize = keepStackSize(); 5090 int stackSize = keepStackSize();
4137 } 5091 }
4138: 5092:
4139 rule__IfElse__Group__3__Impl 5093 rule__Expression__Group_2_1__0__Impl
4140 rule__IfElse__Group__4 5094 rule__Expression__Group_2_1__1
4141; 5095;
4142finally { 5096finally {
4143 restoreStackSize(stackSize); 5097 restoreStackSize(stackSize);
4144} 5098}
4145 5099
4146rule__IfElse__Group__3__Impl 5100rule__Expression__Group_2_1__0__Impl
4147 @init { 5101 @init {
4148 int stackSize = keepStackSize(); 5102 int stackSize = keepStackSize();
4149 } 5103 }
4150: 5104:
4151( 5105(
4152 { before(grammarAccess.getIfElseAccess().getThenAssignment_3()); } 5106 { before(grammarAccess.getExpressionAccess().getForallConditionAction_2_1_0()); }
4153 (rule__IfElse__ThenAssignment_3) 5107 ()
4154 { after(grammarAccess.getIfElseAccess().getThenAssignment_3()); } 5108 { after(grammarAccess.getExpressionAccess().getForallConditionAction_2_1_0()); }
4155) 5109)
4156; 5110;
4157finally { 5111finally {
4158 restoreStackSize(stackSize); 5112 restoreStackSize(stackSize);
4159} 5113}
4160 5114
4161rule__IfElse__Group__4 5115rule__Expression__Group_2_1__1
4162 @init { 5116 @init {
4163 int stackSize = keepStackSize(); 5117 int stackSize = keepStackSize();
4164 } 5118 }
4165: 5119:
4166 rule__IfElse__Group__4__Impl 5120 rule__Expression__Group_2_1__1__Impl
4167 rule__IfElse__Group__5 5121 rule__Expression__Group_2_1__2
4168; 5122;
4169finally { 5123finally {
4170 restoreStackSize(stackSize); 5124 restoreStackSize(stackSize);
4171} 5125}
4172 5126
4173rule__IfElse__Group__4__Impl 5127rule__Expression__Group_2_1__1__Impl
4174 @init { 5128 @init {
4175 int stackSize = keepStackSize(); 5129 int stackSize = keepStackSize();
4176 } 5130 }
4177: 5131:
4178( 5132(
4179 { before(grammarAccess.getIfElseAccess().getElseKeyword_4()); } 5133 { before(grammarAccess.getExpressionAccess().getEqualsSignGreaterThanSignKeyword_2_1_1()); }
4180 Else 5134 EqualsSignGreaterThanSign
4181 { after(grammarAccess.getIfElseAccess().getElseKeyword_4()); } 5135 { after(grammarAccess.getExpressionAccess().getEqualsSignGreaterThanSignKeyword_2_1_1()); }
4182) 5136)
4183; 5137;
4184finally { 5138finally {
4185 restoreStackSize(stackSize); 5139 restoreStackSize(stackSize);
4186} 5140}
4187 5141
4188rule__IfElse__Group__5 5142rule__Expression__Group_2_1__2
4189 @init { 5143 @init {
4190 int stackSize = keepStackSize(); 5144 int stackSize = keepStackSize();
4191 } 5145 }
4192: 5146:
4193 rule__IfElse__Group__5__Impl 5147 rule__Expression__Group_2_1__2__Impl
4194; 5148;
4195finally { 5149finally {
4196 restoreStackSize(stackSize); 5150 restoreStackSize(stackSize);
4197} 5151}
4198 5152
4199rule__IfElse__Group__5__Impl 5153rule__Expression__Group_2_1__2__Impl
4200 @init { 5154 @init {
4201 int stackSize = keepStackSize(); 5155 int stackSize = keepStackSize();
4202 } 5156 }
4203: 5157:
4204( 5158(
4205 { before(grammarAccess.getIfElseAccess().getElseAssignment_5()); } 5159 { before(grammarAccess.getExpressionAccess().getBodyAssignment_2_1_2()); }
4206 (rule__IfElse__ElseAssignment_5) 5160 (rule__Expression__BodyAssignment_2_1_2)
4207 { after(grammarAccess.getIfElseAccess().getElseAssignment_5()); } 5161 { after(grammarAccess.getExpressionAccess().getBodyAssignment_2_1_2()); }
4208) 5162)
4209; 5163;
4210finally { 5164finally {
@@ -4212,269 +5166,296 @@ finally {
4212} 5166}
4213 5167
4214 5168
4215rule__Let__Group__0 5169rule__ConditionalExpression__Group__0
4216 @init { 5170 @init {
4217 int stackSize = keepStackSize(); 5171 int stackSize = keepStackSize();
4218 } 5172 }
4219: 5173:
4220 rule__Let__Group__0__Impl 5174 rule__ConditionalExpression__Group__0__Impl
4221 rule__Let__Group__1 5175 rule__ConditionalExpression__Group__1
4222; 5176;
4223finally { 5177finally {
4224 restoreStackSize(stackSize); 5178 restoreStackSize(stackSize);
4225} 5179}
4226 5180
4227rule__Let__Group__0__Impl 5181rule__ConditionalExpression__Group__0__Impl
4228 @init { 5182 @init {
4229 int stackSize = keepStackSize(); 5183 int stackSize = keepStackSize();
4230 } 5184 }
4231: 5185:
4232( 5186(
4233 { before(grammarAccess.getLetAccess().getLetKeyword_0()); } 5187 { before(grammarAccess.getConditionalExpressionAccess().getIfKeyword_0()); }
4234 Let 5188 If
4235 { after(grammarAccess.getLetAccess().getLetKeyword_0()); } 5189 { after(grammarAccess.getConditionalExpressionAccess().getIfKeyword_0()); }
4236) 5190)
4237; 5191;
4238finally { 5192finally {
4239 restoreStackSize(stackSize); 5193 restoreStackSize(stackSize);
4240} 5194}
4241 5195
4242rule__Let__Group__1 5196rule__ConditionalExpression__Group__1
4243 @init { 5197 @init {
4244 int stackSize = keepStackSize(); 5198 int stackSize = keepStackSize();
4245 } 5199 }
4246: 5200:
4247 rule__Let__Group__1__Impl 5201 rule__ConditionalExpression__Group__1__Impl
4248 rule__Let__Group__2 5202 rule__ConditionalExpression__Group__2
4249; 5203;
4250finally { 5204finally {
4251 restoreStackSize(stackSize); 5205 restoreStackSize(stackSize);
4252} 5206}
4253 5207
4254rule__Let__Group__1__Impl 5208rule__ConditionalExpression__Group__1__Impl
4255 @init { 5209 @init {
4256 int stackSize = keepStackSize(); 5210 int stackSize = keepStackSize();
4257 } 5211 }
4258: 5212:
4259( 5213(
4260 { before(grammarAccess.getLetAccess().getBindingsAssignment_1()); } 5214 { before(grammarAccess.getConditionalExpressionAccess().getConditionAssignment_1()); }
4261 (rule__Let__BindingsAssignment_1) 5215 (rule__ConditionalExpression__ConditionAssignment_1)
4262 { after(grammarAccess.getLetAccess().getBindingsAssignment_1()); } 5216 { after(grammarAccess.getConditionalExpressionAccess().getConditionAssignment_1()); }
4263) 5217)
4264; 5218;
4265finally { 5219finally {
4266 restoreStackSize(stackSize); 5220 restoreStackSize(stackSize);
4267} 5221}
4268 5222
4269rule__Let__Group__2 5223rule__ConditionalExpression__Group__2
4270 @init { 5224 @init {
4271 int stackSize = keepStackSize(); 5225 int stackSize = keepStackSize();
4272 } 5226 }
4273: 5227:
4274 rule__Let__Group__2__Impl 5228 rule__ConditionalExpression__Group__2__Impl
4275 rule__Let__Group__3 5229 rule__ConditionalExpression__Group__3
4276; 5230;
4277finally { 5231finally {
4278 restoreStackSize(stackSize); 5232 restoreStackSize(stackSize);
4279} 5233}
4280 5234
4281rule__Let__Group__2__Impl 5235rule__ConditionalExpression__Group__2__Impl
4282 @init { 5236 @init {
4283 int stackSize = keepStackSize(); 5237 int stackSize = keepStackSize();
4284 } 5238 }
4285: 5239:
4286( 5240(
4287 { before(grammarAccess.getLetAccess().getGroup_2()); } 5241 { before(grammarAccess.getConditionalExpressionAccess().getThenKeyword_2()); }
4288 (rule__Let__Group_2__0)* 5242 Then
4289 { after(grammarAccess.getLetAccess().getGroup_2()); } 5243 { after(grammarAccess.getConditionalExpressionAccess().getThenKeyword_2()); }
4290) 5244)
4291; 5245;
4292finally { 5246finally {
4293 restoreStackSize(stackSize); 5247 restoreStackSize(stackSize);
4294} 5248}
4295 5249
4296rule__Let__Group__3 5250rule__ConditionalExpression__Group__3
4297 @init { 5251 @init {
4298 int stackSize = keepStackSize(); 5252 int stackSize = keepStackSize();
4299 } 5253 }
4300: 5254:
4301 rule__Let__Group__3__Impl 5255 rule__ConditionalExpression__Group__3__Impl
4302 rule__Let__Group__4 5256 rule__ConditionalExpression__Group__4
4303; 5257;
4304finally { 5258finally {
4305 restoreStackSize(stackSize); 5259 restoreStackSize(stackSize);
4306} 5260}
4307 5261
4308rule__Let__Group__3__Impl 5262rule__ConditionalExpression__Group__3__Impl
4309 @init { 5263 @init {
4310 int stackSize = keepStackSize(); 5264 int stackSize = keepStackSize();
4311 } 5265 }
4312: 5266:
4313( 5267(
4314 { before(grammarAccess.getLetAccess().getInKeyword_3()); } 5268 { before(grammarAccess.getConditionalExpressionAccess().getThenAssignment_3()); }
4315 In 5269 (rule__ConditionalExpression__ThenAssignment_3)
4316 { after(grammarAccess.getLetAccess().getInKeyword_3()); } 5270 { after(grammarAccess.getConditionalExpressionAccess().getThenAssignment_3()); }
4317) 5271)
4318; 5272;
4319finally { 5273finally {
4320 restoreStackSize(stackSize); 5274 restoreStackSize(stackSize);
4321} 5275}
4322 5276
4323rule__Let__Group__4 5277rule__ConditionalExpression__Group__4
4324 @init { 5278 @init {
4325 int stackSize = keepStackSize(); 5279 int stackSize = keepStackSize();
4326 } 5280 }
4327: 5281:
4328 rule__Let__Group__4__Impl 5282 rule__ConditionalExpression__Group__4__Impl
5283 rule__ConditionalExpression__Group__5
4329; 5284;
4330finally { 5285finally {
4331 restoreStackSize(stackSize); 5286 restoreStackSize(stackSize);
4332} 5287}
4333 5288
4334rule__Let__Group__4__Impl 5289rule__ConditionalExpression__Group__4__Impl
4335 @init { 5290 @init {
4336 int stackSize = keepStackSize(); 5291 int stackSize = keepStackSize();
4337 } 5292 }
4338: 5293:
4339( 5294(
4340 { before(grammarAccess.getLetAccess().getBodyAssignment_4()); } 5295 { before(grammarAccess.getConditionalExpressionAccess().getElseKeyword_4()); }
4341 (rule__Let__BodyAssignment_4) 5296 Else
4342 { after(grammarAccess.getLetAccess().getBodyAssignment_4()); } 5297 { after(grammarAccess.getConditionalExpressionAccess().getElseKeyword_4()); }
4343) 5298)
4344; 5299;
4345finally { 5300finally {
4346 restoreStackSize(stackSize); 5301 restoreStackSize(stackSize);
4347} 5302}
4348 5303
4349 5304rule__ConditionalExpression__Group__5
4350rule__Let__Group_2__0
4351 @init { 5305 @init {
4352 int stackSize = keepStackSize(); 5306 int stackSize = keepStackSize();
4353 } 5307 }
4354: 5308:
4355 rule__Let__Group_2__0__Impl 5309 rule__ConditionalExpression__Group__5__Impl
4356 rule__Let__Group_2__1
4357; 5310;
4358finally { 5311finally {
4359 restoreStackSize(stackSize); 5312 restoreStackSize(stackSize);
4360} 5313}
4361 5314
4362rule__Let__Group_2__0__Impl 5315rule__ConditionalExpression__Group__5__Impl
4363 @init { 5316 @init {
4364 int stackSize = keepStackSize(); 5317 int stackSize = keepStackSize();
4365 } 5318 }
4366: 5319:
4367( 5320(
4368 { before(grammarAccess.getLetAccess().getCommaKeyword_2_0()); } 5321 { before(grammarAccess.getConditionalExpressionAccess().getElseAssignment_5()); }
4369 Comma 5322 (rule__ConditionalExpression__ElseAssignment_5)
4370 { after(grammarAccess.getLetAccess().getCommaKeyword_2_0()); } 5323 { after(grammarAccess.getConditionalExpressionAccess().getElseAssignment_5()); }
4371) 5324)
4372; 5325;
4373finally { 5326finally {
4374 restoreStackSize(stackSize); 5327 restoreStackSize(stackSize);
4375} 5328}
4376 5329
4377rule__Let__Group_2__1 5330
5331rule__LetExpression__Group__0
4378 @init { 5332 @init {
4379 int stackSize = keepStackSize(); 5333 int stackSize = keepStackSize();
4380 } 5334 }
4381: 5335:
4382 rule__Let__Group_2__1__Impl 5336 rule__LetExpression__Group__0__Impl
5337 rule__LetExpression__Group__1
4383; 5338;
4384finally { 5339finally {
4385 restoreStackSize(stackSize); 5340 restoreStackSize(stackSize);
4386} 5341}
4387 5342
4388rule__Let__Group_2__1__Impl 5343rule__LetExpression__Group__0__Impl
4389 @init { 5344 @init {
4390 int stackSize = keepStackSize(); 5345 int stackSize = keepStackSize();
4391 } 5346 }
4392: 5347:
4393( 5348(
4394 { before(grammarAccess.getLetAccess().getBindingsAssignment_2_1()); } 5349 { before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); }
4395 (rule__Let__BindingsAssignment_2_1) 5350 Let
4396 { after(grammarAccess.getLetAccess().getBindingsAssignment_2_1()); } 5351 { after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); }
4397) 5352)
4398; 5353;
4399finally { 5354finally {
4400 restoreStackSize(stackSize); 5355 restoreStackSize(stackSize);
4401} 5356}
4402 5357
5358rule__LetExpression__Group__1
5359 @init {
5360 int stackSize = keepStackSize();
5361 }
5362:
5363 rule__LetExpression__Group__1__Impl
5364 rule__LetExpression__Group__2
5365;
5366finally {
5367 restoreStackSize(stackSize);
5368}
4403 5369
4404rule__LetBinding__Group__0 5370rule__LetExpression__Group__1__Impl
4405 @init { 5371 @init {
4406 int stackSize = keepStackSize(); 5372 int stackSize = keepStackSize();
4407 } 5373 }
4408: 5374:
4409 rule__LetBinding__Group__0__Impl 5375(
4410 rule__LetBinding__Group__1 5376 { before(grammarAccess.getLetExpressionAccess().getBindingsAssignment_1()); }
5377 (rule__LetExpression__BindingsAssignment_1)
5378 { after(grammarAccess.getLetExpressionAccess().getBindingsAssignment_1()); }
5379)
4411; 5380;
4412finally { 5381finally {
4413 restoreStackSize(stackSize); 5382 restoreStackSize(stackSize);
4414} 5383}
4415 5384
4416rule__LetBinding__Group__0__Impl 5385rule__LetExpression__Group__2
5386 @init {
5387 int stackSize = keepStackSize();
5388 }
5389:
5390 rule__LetExpression__Group__2__Impl
5391 rule__LetExpression__Group__3
5392;
5393finally {
5394 restoreStackSize(stackSize);
5395}
5396
5397rule__LetExpression__Group__2__Impl
4417 @init { 5398 @init {
4418 int stackSize = keepStackSize(); 5399 int stackSize = keepStackSize();
4419 } 5400 }
4420: 5401:
4421( 5402(
4422 { before(grammarAccess.getLetBindingAccess().getVariableAssignment_0()); } 5403 { before(grammarAccess.getLetExpressionAccess().getGroup_2()); }
4423 (rule__LetBinding__VariableAssignment_0) 5404 (rule__LetExpression__Group_2__0)*
4424 { after(grammarAccess.getLetBindingAccess().getVariableAssignment_0()); } 5405 { after(grammarAccess.getLetExpressionAccess().getGroup_2()); }
4425) 5406)
4426; 5407;
4427finally { 5408finally {
4428 restoreStackSize(stackSize); 5409 restoreStackSize(stackSize);
4429} 5410}
4430 5411
4431rule__LetBinding__Group__1 5412rule__LetExpression__Group__3
4432 @init { 5413 @init {
4433 int stackSize = keepStackSize(); 5414 int stackSize = keepStackSize();
4434 } 5415 }
4435: 5416:
4436 rule__LetBinding__Group__1__Impl 5417 rule__LetExpression__Group__3__Impl
4437 rule__LetBinding__Group__2 5418 rule__LetExpression__Group__4
4438; 5419;
4439finally { 5420finally {
4440 restoreStackSize(stackSize); 5421 restoreStackSize(stackSize);
4441} 5422}
4442 5423
4443rule__LetBinding__Group__1__Impl 5424rule__LetExpression__Group__3__Impl
4444 @init { 5425 @init {
4445 int stackSize = keepStackSize(); 5426 int stackSize = keepStackSize();
4446 } 5427 }
4447: 5428:
4448( 5429(
4449 { before(grammarAccess.getLetBindingAccess().getEqualsSignKeyword_1()); } 5430 { before(grammarAccess.getLetExpressionAccess().getInKeyword_3()); }
4450 EqualsSign 5431 In
4451 { after(grammarAccess.getLetBindingAccess().getEqualsSignKeyword_1()); } 5432 { after(grammarAccess.getLetExpressionAccess().getInKeyword_3()); }
4452) 5433)
4453; 5434;
4454finally { 5435finally {
4455 restoreStackSize(stackSize); 5436 restoreStackSize(stackSize);
4456} 5437}
4457 5438
4458rule__LetBinding__Group__2 5439rule__LetExpression__Group__4
4459 @init { 5440 @init {
4460 int stackSize = keepStackSize(); 5441 int stackSize = keepStackSize();
4461 } 5442 }
4462: 5443:
4463 rule__LetBinding__Group__2__Impl 5444 rule__LetExpression__Group__4__Impl
4464; 5445;
4465finally { 5446finally {
4466 restoreStackSize(stackSize); 5447 restoreStackSize(stackSize);
4467} 5448}
4468 5449
4469rule__LetBinding__Group__2__Impl 5450rule__LetExpression__Group__4__Impl
4470 @init { 5451 @init {
4471 int stackSize = keepStackSize(); 5452 int stackSize = keepStackSize();
4472 } 5453 }
4473: 5454:
4474( 5455(
4475 { before(grammarAccess.getLetBindingAccess().getValueAssignment_2()); } 5456 { before(grammarAccess.getLetExpressionAccess().getBodyAssignment_4()); }
4476 (rule__LetBinding__ValueAssignment_2) 5457 (rule__LetExpression__BodyAssignment_4)
4477 { after(grammarAccess.getLetBindingAccess().getValueAssignment_2()); } 5458 { after(grammarAccess.getLetExpressionAccess().getBodyAssignment_4()); }
4478) 5459)
4479; 5460;
4480finally { 5461finally {
@@ -4482,53 +5463,53 @@ finally {
4482} 5463}
4483 5464
4484 5465
4485rule__ImplicationExpression__Group__0 5466rule__LetExpression__Group_2__0
4486 @init { 5467 @init {
4487 int stackSize = keepStackSize(); 5468 int stackSize = keepStackSize();
4488 } 5469 }
4489: 5470:
4490 rule__ImplicationExpression__Group__0__Impl 5471 rule__LetExpression__Group_2__0__Impl
4491 rule__ImplicationExpression__Group__1 5472 rule__LetExpression__Group_2__1
4492; 5473;
4493finally { 5474finally {
4494 restoreStackSize(stackSize); 5475 restoreStackSize(stackSize);
4495} 5476}
4496 5477
4497rule__ImplicationExpression__Group__0__Impl 5478rule__LetExpression__Group_2__0__Impl
4498 @init { 5479 @init {
4499 int stackSize = keepStackSize(); 5480 int stackSize = keepStackSize();
4500 } 5481 }
4501: 5482:
4502( 5483(
4503 { before(grammarAccess.getImplicationExpressionAccess().getDisjunctiveExpressionParserRuleCall_0()); } 5484 { before(grammarAccess.getLetExpressionAccess().getCommaKeyword_2_0()); }
4504 ruleDisjunctiveExpression 5485 Comma
4505 { after(grammarAccess.getImplicationExpressionAccess().getDisjunctiveExpressionParserRuleCall_0()); } 5486 { after(grammarAccess.getLetExpressionAccess().getCommaKeyword_2_0()); }
4506) 5487)
4507; 5488;
4508finally { 5489finally {
4509 restoreStackSize(stackSize); 5490 restoreStackSize(stackSize);
4510} 5491}
4511 5492
4512rule__ImplicationExpression__Group__1 5493rule__LetExpression__Group_2__1
4513 @init { 5494 @init {
4514 int stackSize = keepStackSize(); 5495 int stackSize = keepStackSize();
4515 } 5496 }
4516: 5497:
4517 rule__ImplicationExpression__Group__1__Impl 5498 rule__LetExpression__Group_2__1__Impl
4518; 5499;
4519finally { 5500finally {
4520 restoreStackSize(stackSize); 5501 restoreStackSize(stackSize);
4521} 5502}
4522 5503
4523rule__ImplicationExpression__Group__1__Impl 5504rule__LetExpression__Group_2__1__Impl
4524 @init { 5505 @init {
4525 int stackSize = keepStackSize(); 5506 int stackSize = keepStackSize();
4526 } 5507 }
4527: 5508:
4528( 5509(
4529 { before(grammarAccess.getImplicationExpressionAccess().getGroup_1()); } 5510 { before(grammarAccess.getLetExpressionAccess().getBindingsAssignment_2_1()); }
4530 (rule__ImplicationExpression__Group_1__0)? 5511 (rule__LetExpression__BindingsAssignment_2_1)
4531 { after(grammarAccess.getImplicationExpressionAccess().getGroup_1()); } 5512 { after(grammarAccess.getLetExpressionAccess().getBindingsAssignment_2_1()); }
4532) 5513)
4533; 5514;
4534finally { 5515finally {
@@ -4536,80 +5517,107 @@ finally {
4536} 5517}
4537 5518
4538 5519
4539rule__ImplicationExpression__Group_1__0 5520rule__LetBinding__Group__0
4540 @init { 5521 @init {
4541 int stackSize = keepStackSize(); 5522 int stackSize = keepStackSize();
4542 } 5523 }
4543: 5524:
4544 rule__ImplicationExpression__Group_1__0__Impl 5525 rule__LetBinding__Group__0__Impl
4545 rule__ImplicationExpression__Group_1__1 5526 rule__LetBinding__Group__1
4546; 5527;
4547finally { 5528finally {
4548 restoreStackSize(stackSize); 5529 restoreStackSize(stackSize);
4549} 5530}
4550 5531
4551rule__ImplicationExpression__Group_1__0__Impl 5532rule__LetBinding__Group__0__Impl
4552 @init { 5533 @init {
4553 int stackSize = keepStackSize(); 5534 int stackSize = keepStackSize();
4554 } 5535 }
4555: 5536:
4556( 5537(
4557 { before(grammarAccess.getImplicationExpressionAccess().getBinaryExpressionLeftAction_1_0()); } 5538 { before(grammarAccess.getLetBindingAccess().getTypeAssignment_0()); }
4558 () 5539 (rule__LetBinding__TypeAssignment_0)?
4559 { after(grammarAccess.getImplicationExpressionAccess().getBinaryExpressionLeftAction_1_0()); } 5540 { after(grammarAccess.getLetBindingAccess().getTypeAssignment_0()); }
4560) 5541)
4561; 5542;
4562finally { 5543finally {
4563 restoreStackSize(stackSize); 5544 restoreStackSize(stackSize);
4564} 5545}
4565 5546
4566rule__ImplicationExpression__Group_1__1 5547rule__LetBinding__Group__1
4567 @init { 5548 @init {
4568 int stackSize = keepStackSize(); 5549 int stackSize = keepStackSize();
4569 } 5550 }
4570: 5551:
4571 rule__ImplicationExpression__Group_1__1__Impl 5552 rule__LetBinding__Group__1__Impl
4572 rule__ImplicationExpression__Group_1__2 5553 rule__LetBinding__Group__2
4573; 5554;
4574finally { 5555finally {
4575 restoreStackSize(stackSize); 5556 restoreStackSize(stackSize);
4576} 5557}
4577 5558
4578rule__ImplicationExpression__Group_1__1__Impl 5559rule__LetBinding__Group__1__Impl
4579 @init { 5560 @init {
4580 int stackSize = keepStackSize(); 5561 int stackSize = keepStackSize();
4581 } 5562 }
4582: 5563:
4583( 5564(
4584 { before(grammarAccess.getImplicationExpressionAccess().getOpAssignment_1_1()); } 5565 { before(grammarAccess.getLetBindingAccess().getNameAssignment_1()); }
4585 (rule__ImplicationExpression__OpAssignment_1_1) 5566 (rule__LetBinding__NameAssignment_1)
4586 { after(grammarAccess.getImplicationExpressionAccess().getOpAssignment_1_1()); } 5567 { after(grammarAccess.getLetBindingAccess().getNameAssignment_1()); }
4587) 5568)
4588; 5569;
4589finally { 5570finally {
4590 restoreStackSize(stackSize); 5571 restoreStackSize(stackSize);
4591} 5572}
4592 5573
4593rule__ImplicationExpression__Group_1__2 5574rule__LetBinding__Group__2
4594 @init { 5575 @init {
4595 int stackSize = keepStackSize(); 5576 int stackSize = keepStackSize();
4596 } 5577 }
4597: 5578:
4598 rule__ImplicationExpression__Group_1__2__Impl 5579 rule__LetBinding__Group__2__Impl
5580 rule__LetBinding__Group__3
4599; 5581;
4600finally { 5582finally {
4601 restoreStackSize(stackSize); 5583 restoreStackSize(stackSize);
4602} 5584}
4603 5585
4604rule__ImplicationExpression__Group_1__2__Impl 5586rule__LetBinding__Group__2__Impl
4605 @init { 5587 @init {
4606 int stackSize = keepStackSize(); 5588 int stackSize = keepStackSize();
4607 } 5589 }
4608: 5590:
4609( 5591(
4610 { before(grammarAccess.getImplicationExpressionAccess().getRightAssignment_1_2()); } 5592 { before(grammarAccess.getLetBindingAccess().getEqualsSignKeyword_2()); }
4611 (rule__ImplicationExpression__RightAssignment_1_2) 5593 EqualsSign
4612 { after(grammarAccess.getImplicationExpressionAccess().getRightAssignment_1_2()); } 5594 { after(grammarAccess.getLetBindingAccess().getEqualsSignKeyword_2()); }
5595)
5596;
5597finally {
5598 restoreStackSize(stackSize);
5599}
5600
5601rule__LetBinding__Group__3
5602 @init {
5603 int stackSize = keepStackSize();
5604 }
5605:
5606 rule__LetBinding__Group__3__Impl
5607;
5608finally {
5609 restoreStackSize(stackSize);
5610}
5611
5612rule__LetBinding__Group__3__Impl
5613 @init {
5614 int stackSize = keepStackSize();
5615 }
5616:
5617(
5618 { before(grammarAccess.getLetBindingAccess().getValueAssignment_3()); }
5619 (rule__LetBinding__ValueAssignment_3)
5620 { after(grammarAccess.getLetBindingAccess().getValueAssignment_3()); }
4613) 5621)
4614; 5622;
4615finally { 5623finally {
@@ -5297,9 +6305,9 @@ rule__ComparisonExpression__Group_1__0__Impl
5297 } 6305 }
5298: 6306:
5299( 6307(
5300 { before(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0()); } 6308 { before(grammarAccess.getComparisonExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
5301 () 6309 ()
5302 { after(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0()); } 6310 { after(grammarAccess.getComparisonExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
5303) 6311)
5304; 6312;
5305finally { 6313finally {
@@ -5890,9 +6898,9 @@ rule__CastExpression__Group_1__2__Impl
5890 } 6898 }
5891: 6899:
5892( 6900(
5893 { before(grammarAccess.getCastExpressionAccess().getTypeAssignment_1_2()); } 6901 { before(grammarAccess.getCastExpressionAccess().getTargetTypeAssignment_1_2()); }
5894 (rule__CastExpression__TypeAssignment_1_2) 6902 (rule__CastExpression__TargetTypeAssignment_1_2)
5895 { after(grammarAccess.getCastExpressionAccess().getTypeAssignment_1_2()); } 6903 { after(grammarAccess.getCastExpressionAccess().getTargetTypeAssignment_1_2()); }
5896) 6904)
5897; 6905;
5898finally { 6906finally {
@@ -5981,215 +6989,161 @@ finally {
5981} 6989}
5982 6990
5983 6991
5984rule__LocalVariables__Group__0 6992rule__Aggregation__Group__0
5985 @init {
5986 int stackSize = keepStackSize();
5987 }
5988:
5989 rule__LocalVariables__Group__0__Impl
5990 rule__LocalVariables__Group__1
5991;
5992finally {
5993 restoreStackSize(stackSize);
5994}
5995
5996rule__LocalVariables__Group__0__Impl
5997 @init {
5998 int stackSize = keepStackSize();
5999 }
6000:
6001(
6002 { before(grammarAccess.getLocalVariablesAccess().getLocalVariablesAction_0()); }
6003 ()
6004 { after(grammarAccess.getLocalVariablesAccess().getLocalVariablesAction_0()); }
6005)
6006;
6007finally {
6008 restoreStackSize(stackSize);
6009}
6010
6011rule__LocalVariables__Group__1
6012 @init {
6013 int stackSize = keepStackSize();
6014 }
6015:
6016 rule__LocalVariables__Group__1__Impl
6017 rule__LocalVariables__Group__2
6018;
6019finally {
6020 restoreStackSize(stackSize);
6021}
6022
6023rule__LocalVariables__Group__1__Impl
6024 @init {
6025 int stackSize = keepStackSize();
6026 }
6027:
6028(
6029 { before(grammarAccess.getLocalVariablesAccess().getLeftSquareBracketKeyword_1()); }
6030 LeftSquareBracket
6031 { after(grammarAccess.getLocalVariablesAccess().getLeftSquareBracketKeyword_1()); }
6032)
6033;
6034finally {
6035 restoreStackSize(stackSize);
6036}
6037
6038rule__LocalVariables__Group__2
6039 @init { 6993 @init {
6040 int stackSize = keepStackSize(); 6994 int stackSize = keepStackSize();
6041 } 6995 }
6042: 6996:
6043 rule__LocalVariables__Group__2__Impl 6997 rule__Aggregation__Group__0__Impl
6044 rule__LocalVariables__Group__3 6998 rule__Aggregation__Group__1
6045; 6999;
6046finally { 7000finally {
6047 restoreStackSize(stackSize); 7001 restoreStackSize(stackSize);
6048} 7002}
6049 7003
6050rule__LocalVariables__Group__2__Impl 7004rule__Aggregation__Group__0__Impl
6051 @init { 7005 @init {
6052 int stackSize = keepStackSize(); 7006 int stackSize = keepStackSize();
6053 } 7007 }
6054: 7008:
6055( 7009(
6056 { before(grammarAccess.getLocalVariablesAccess().getGroup_2()); } 7010 { before(grammarAccess.getAggregationAccess().getOpAssignment_0()); }
6057 (rule__LocalVariables__Group_2__0)? 7011 (rule__Aggregation__OpAssignment_0)
6058 { after(grammarAccess.getLocalVariablesAccess().getGroup_2()); } 7012 { after(grammarAccess.getAggregationAccess().getOpAssignment_0()); }
6059) 7013)
6060; 7014;
6061finally { 7015finally {
6062 restoreStackSize(stackSize); 7016 restoreStackSize(stackSize);
6063} 7017}
6064 7018
6065rule__LocalVariables__Group__3 7019rule__Aggregation__Group__1
6066 @init { 7020 @init {
6067 int stackSize = keepStackSize(); 7021 int stackSize = keepStackSize();
6068 } 7022 }
6069: 7023:
6070 rule__LocalVariables__Group__3__Impl 7024 rule__Aggregation__Group__1__Impl
7025 rule__Aggregation__Group__2
6071; 7026;
6072finally { 7027finally {
6073 restoreStackSize(stackSize); 7028 restoreStackSize(stackSize);
6074} 7029}
6075 7030
6076rule__LocalVariables__Group__3__Impl 7031rule__Aggregation__Group__1__Impl
6077 @init { 7032 @init {
6078 int stackSize = keepStackSize(); 7033 int stackSize = keepStackSize();
6079 } 7034 }
6080: 7035:
6081( 7036(
6082 { before(grammarAccess.getLocalVariablesAccess().getRightSquareBracketKeyword_3()); } 7037 { before(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); }
6083 RightSquareBracket 7038 LeftCurlyBracket
6084 { after(grammarAccess.getLocalVariablesAccess().getRightSquareBracketKeyword_3()); } 7039 { after(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); }
6085) 7040)
6086; 7041;
6087finally { 7042finally {
6088 restoreStackSize(stackSize); 7043 restoreStackSize(stackSize);
6089} 7044}
6090 7045
6091 7046rule__Aggregation__Group__2
6092rule__LocalVariables__Group_2__0
6093 @init { 7047 @init {
6094 int stackSize = keepStackSize(); 7048 int stackSize = keepStackSize();
6095 } 7049 }
6096: 7050:
6097 rule__LocalVariables__Group_2__0__Impl 7051 rule__Aggregation__Group__2__Impl
6098 rule__LocalVariables__Group_2__1 7052 rule__Aggregation__Group__3
6099; 7053;
6100finally { 7054finally {
6101 restoreStackSize(stackSize); 7055 restoreStackSize(stackSize);
6102} 7056}
6103 7057
6104rule__LocalVariables__Group_2__0__Impl 7058rule__Aggregation__Group__2__Impl
6105 @init { 7059 @init {
6106 int stackSize = keepStackSize(); 7060 int stackSize = keepStackSize();
6107 } 7061 }
6108: 7062:
6109( 7063(
6110 { before(grammarAccess.getLocalVariablesAccess().getVariablesAssignment_2_0()); } 7064 { before(grammarAccess.getAggregationAccess().getValueAssignment_2()); }
6111 (rule__LocalVariables__VariablesAssignment_2_0) 7065 (rule__Aggregation__ValueAssignment_2)
6112 { after(grammarAccess.getLocalVariablesAccess().getVariablesAssignment_2_0()); } 7066 { after(grammarAccess.getAggregationAccess().getValueAssignment_2()); }
6113) 7067)
6114; 7068;
6115finally { 7069finally {
6116 restoreStackSize(stackSize); 7070 restoreStackSize(stackSize);
6117} 7071}
6118 7072
6119rule__LocalVariables__Group_2__1 7073rule__Aggregation__Group__3
6120 @init { 7074 @init {
6121 int stackSize = keepStackSize(); 7075 int stackSize = keepStackSize();
6122 } 7076 }
6123: 7077:
6124 rule__LocalVariables__Group_2__1__Impl 7078 rule__Aggregation__Group__3__Impl
7079 rule__Aggregation__Group__4
6125; 7080;
6126finally { 7081finally {
6127 restoreStackSize(stackSize); 7082 restoreStackSize(stackSize);
6128} 7083}
6129 7084
6130rule__LocalVariables__Group_2__1__Impl 7085rule__Aggregation__Group__3__Impl
6131 @init { 7086 @init {
6132 int stackSize = keepStackSize(); 7087 int stackSize = keepStackSize();
6133 } 7088 }
6134: 7089:
6135( 7090(
6136 { before(grammarAccess.getLocalVariablesAccess().getGroup_2_1()); } 7091 { before(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); }
6137 (rule__LocalVariables__Group_2_1__0)* 7092 VerticalLine
6138 { after(grammarAccess.getLocalVariablesAccess().getGroup_2_1()); } 7093 { after(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); }
6139) 7094)
6140; 7095;
6141finally { 7096finally {
6142 restoreStackSize(stackSize); 7097 restoreStackSize(stackSize);
6143} 7098}
6144 7099
6145 7100rule__Aggregation__Group__4
6146rule__LocalVariables__Group_2_1__0
6147 @init { 7101 @init {
6148 int stackSize = keepStackSize(); 7102 int stackSize = keepStackSize();
6149 } 7103 }
6150: 7104:
6151 rule__LocalVariables__Group_2_1__0__Impl 7105 rule__Aggregation__Group__4__Impl
6152 rule__LocalVariables__Group_2_1__1 7106 rule__Aggregation__Group__5
6153; 7107;
6154finally { 7108finally {
6155 restoreStackSize(stackSize); 7109 restoreStackSize(stackSize);
6156} 7110}
6157 7111
6158rule__LocalVariables__Group_2_1__0__Impl 7112rule__Aggregation__Group__4__Impl
6159 @init { 7113 @init {
6160 int stackSize = keepStackSize(); 7114 int stackSize = keepStackSize();
6161 } 7115 }
6162: 7116:
6163( 7117(
6164 { before(grammarAccess.getLocalVariablesAccess().getCommaKeyword_2_1_0()); } 7118 { before(grammarAccess.getAggregationAccess().getConditionAssignment_4()); }
6165 Comma 7119 (rule__Aggregation__ConditionAssignment_4)
6166 { after(grammarAccess.getLocalVariablesAccess().getCommaKeyword_2_1_0()); } 7120 { after(grammarAccess.getAggregationAccess().getConditionAssignment_4()); }
6167) 7121)
6168; 7122;
6169finally { 7123finally {
6170 restoreStackSize(stackSize); 7124 restoreStackSize(stackSize);
6171} 7125}
6172 7126
6173rule__LocalVariables__Group_2_1__1 7127rule__Aggregation__Group__5
6174 @init { 7128 @init {
6175 int stackSize = keepStackSize(); 7129 int stackSize = keepStackSize();
6176 } 7130 }
6177: 7131:
6178 rule__LocalVariables__Group_2_1__1__Impl 7132 rule__Aggregation__Group__5__Impl
6179; 7133;
6180finally { 7134finally {
6181 restoreStackSize(stackSize); 7135 restoreStackSize(stackSize);
6182} 7136}
6183 7137
6184rule__LocalVariables__Group_2_1__1__Impl 7138rule__Aggregation__Group__5__Impl
6185 @init { 7139 @init {
6186 int stackSize = keepStackSize(); 7140 int stackSize = keepStackSize();
6187 } 7141 }
6188: 7142:
6189( 7143(
6190 { before(grammarAccess.getLocalVariablesAccess().getVariablesAssignment_2_1_1()); } 7144 { before(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); }
6191 (rule__LocalVariables__VariablesAssignment_2_1_1) 7145 RightCurlyBracket
6192 { after(grammarAccess.getLocalVariablesAccess().getVariablesAssignment_2_1_1()); } 7146 { after(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); }
6193) 7147)
6194; 7148;
6195finally { 7149finally {
@@ -6197,134 +7151,107 @@ finally {
6197} 7151}
6198 7152
6199 7153
6200rule__QuantifiedExpression__Group__0 7154rule__Count__Group__0
6201 @init {
6202 int stackSize = keepStackSize();
6203 }
6204:
6205 rule__QuantifiedExpression__Group__0__Impl
6206 rule__QuantifiedExpression__Group__1
6207;
6208finally {
6209 restoreStackSize(stackSize);
6210}
6211
6212rule__QuantifiedExpression__Group__0__Impl
6213 @init {
6214 int stackSize = keepStackSize();
6215 }
6216:
6217(
6218 { before(grammarAccess.getQuantifiedExpressionAccess().getQuantifierAssignment_0()); }
6219 (rule__QuantifiedExpression__QuantifierAssignment_0)
6220 { after(grammarAccess.getQuantifiedExpressionAccess().getQuantifierAssignment_0()); }
6221)
6222;
6223finally {
6224 restoreStackSize(stackSize);
6225}
6226
6227rule__QuantifiedExpression__Group__1
6228 @init { 7155 @init {
6229 int stackSize = keepStackSize(); 7156 int stackSize = keepStackSize();
6230 } 7157 }
6231: 7158:
6232 rule__QuantifiedExpression__Group__1__Impl 7159 rule__Count__Group__0__Impl
6233 rule__QuantifiedExpression__Group__2 7160 rule__Count__Group__1
6234; 7161;
6235finally { 7162finally {
6236 restoreStackSize(stackSize); 7163 restoreStackSize(stackSize);
6237} 7164}
6238 7165
6239rule__QuantifiedExpression__Group__1__Impl 7166rule__Count__Group__0__Impl
6240 @init { 7167 @init {
6241 int stackSize = keepStackSize(); 7168 int stackSize = keepStackSize();
6242 } 7169 }
6243: 7170:
6244( 7171(
6245 { before(grammarAccess.getQuantifiedExpressionAccess().getLocalVariablesAssignment_1()); } 7172 { before(grammarAccess.getCountAccess().getCountKeyword_0()); }
6246 (rule__QuantifiedExpression__LocalVariablesAssignment_1)? 7173 Count
6247 { after(grammarAccess.getQuantifiedExpressionAccess().getLocalVariablesAssignment_1()); } 7174 { after(grammarAccess.getCountAccess().getCountKeyword_0()); }
6248) 7175)
6249; 7176;
6250finally { 7177finally {
6251 restoreStackSize(stackSize); 7178 restoreStackSize(stackSize);
6252} 7179}
6253 7180
6254rule__QuantifiedExpression__Group__2 7181rule__Count__Group__1
6255 @init { 7182 @init {
6256 int stackSize = keepStackSize(); 7183 int stackSize = keepStackSize();
6257 } 7184 }
6258: 7185:
6259 rule__QuantifiedExpression__Group__2__Impl 7186 rule__Count__Group__1__Impl
6260 rule__QuantifiedExpression__Group__3 7187 rule__Count__Group__2
6261; 7188;
6262finally { 7189finally {
6263 restoreStackSize(stackSize); 7190 restoreStackSize(stackSize);
6264} 7191}
6265 7192
6266rule__QuantifiedExpression__Group__2__Impl 7193rule__Count__Group__1__Impl
6267 @init { 7194 @init {
6268 int stackSize = keepStackSize(); 7195 int stackSize = keepStackSize();
6269 } 7196 }
6270: 7197:
6271( 7198(
6272 { before(grammarAccess.getQuantifiedExpressionAccess().getLeftCurlyBracketKeyword_2()); } 7199 { before(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); }
6273 LeftCurlyBracket 7200 LeftCurlyBracket
6274 { after(grammarAccess.getQuantifiedExpressionAccess().getLeftCurlyBracketKeyword_2()); } 7201 { after(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); }
6275) 7202)
6276; 7203;
6277finally { 7204finally {
6278 restoreStackSize(stackSize); 7205 restoreStackSize(stackSize);
6279} 7206}
6280 7207
6281rule__QuantifiedExpression__Group__3 7208rule__Count__Group__2
6282 @init { 7209 @init {
6283 int stackSize = keepStackSize(); 7210 int stackSize = keepStackSize();
6284 } 7211 }
6285: 7212:
6286 rule__QuantifiedExpression__Group__3__Impl 7213 rule__Count__Group__2__Impl
6287 rule__QuantifiedExpression__Group__4 7214 rule__Count__Group__3
6288; 7215;
6289finally { 7216finally {
6290 restoreStackSize(stackSize); 7217 restoreStackSize(stackSize);
6291} 7218}
6292 7219
6293rule__QuantifiedExpression__Group__3__Impl 7220rule__Count__Group__2__Impl
6294 @init { 7221 @init {
6295 int stackSize = keepStackSize(); 7222 int stackSize = keepStackSize();
6296 } 7223 }
6297: 7224:
6298( 7225(
6299 { before(grammarAccess.getQuantifiedExpressionAccess().getBodyAssignment_3()); } 7226 { before(grammarAccess.getCountAccess().getConditionAssignment_2()); }
6300 (rule__QuantifiedExpression__BodyAssignment_3) 7227 (rule__Count__ConditionAssignment_2)
6301 { after(grammarAccess.getQuantifiedExpressionAccess().getBodyAssignment_3()); } 7228 { after(grammarAccess.getCountAccess().getConditionAssignment_2()); }
6302) 7229)
6303; 7230;
6304finally { 7231finally {
6305 restoreStackSize(stackSize); 7232 restoreStackSize(stackSize);
6306} 7233}
6307 7234
6308rule__QuantifiedExpression__Group__4 7235rule__Count__Group__3
6309 @init { 7236 @init {
6310 int stackSize = keepStackSize(); 7237 int stackSize = keepStackSize();
6311 } 7238 }
6312: 7239:
6313 rule__QuantifiedExpression__Group__4__Impl 7240 rule__Count__Group__3__Impl
6314; 7241;
6315finally { 7242finally {
6316 restoreStackSize(stackSize); 7243 restoreStackSize(stackSize);
6317} 7244}
6318 7245
6319rule__QuantifiedExpression__Group__4__Impl 7246rule__Count__Group__3__Impl
6320 @init { 7247 @init {
6321 int stackSize = keepStackSize(); 7248 int stackSize = keepStackSize();
6322 } 7249 }
6323: 7250:
6324( 7251(
6325 { before(grammarAccess.getQuantifiedExpressionAccess().getRightCurlyBracketKeyword_4()); } 7252 { before(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); }
6326 RightCurlyBracket 7253 RightCurlyBracket
6327 { after(grammarAccess.getQuantifiedExpressionAccess().getRightCurlyBracketKeyword_4()); } 7254 { after(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); }
6328) 7255)
6329; 7256;
6330finally { 7257finally {
@@ -6332,161 +7259,134 @@ finally {
6332} 7259}
6333 7260
6334 7261
6335rule__Aggregation__Group__0 7262rule__AtomicExpression__Group_4__0
6336 @init { 7263 @init {
6337 int stackSize = keepStackSize(); 7264 int stackSize = keepStackSize();
6338 } 7265 }
6339: 7266:
6340 rule__Aggregation__Group__0__Impl 7267 rule__AtomicExpression__Group_4__0__Impl
6341 rule__Aggregation__Group__1 7268 rule__AtomicExpression__Group_4__1
6342; 7269;
6343finally { 7270finally {
6344 restoreStackSize(stackSize); 7271 restoreStackSize(stackSize);
6345} 7272}
6346 7273
6347rule__Aggregation__Group__0__Impl 7274rule__AtomicExpression__Group_4__0__Impl
6348 @init { 7275 @init {
6349 int stackSize = keepStackSize(); 7276 int stackSize = keepStackSize();
6350 } 7277 }
6351: 7278:
6352( 7279(
6353 { before(grammarAccess.getAggregationAccess().getOpAssignment_0()); } 7280 { before(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); }
6354 (rule__Aggregation__OpAssignment_0) 7281 LeftParenthesis
6355 { after(grammarAccess.getAggregationAccess().getOpAssignment_0()); } 7282 { after(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); }
6356) 7283)
6357; 7284;
6358finally { 7285finally {
6359 restoreStackSize(stackSize); 7286 restoreStackSize(stackSize);
6360} 7287}
6361 7288
6362rule__Aggregation__Group__1 7289rule__AtomicExpression__Group_4__1
6363 @init { 7290 @init {
6364 int stackSize = keepStackSize(); 7291 int stackSize = keepStackSize();
6365 } 7292 }
6366: 7293:
6367 rule__Aggregation__Group__1__Impl 7294 rule__AtomicExpression__Group_4__1__Impl
6368 rule__Aggregation__Group__2 7295 rule__AtomicExpression__Group_4__2
6369; 7296;
6370finally { 7297finally {
6371 restoreStackSize(stackSize); 7298 restoreStackSize(stackSize);
6372} 7299}
6373 7300
6374rule__Aggregation__Group__1__Impl 7301rule__AtomicExpression__Group_4__1__Impl
6375 @init { 7302 @init {
6376 int stackSize = keepStackSize(); 7303 int stackSize = keepStackSize();
6377 } 7304 }
6378: 7305:
6379( 7306(
6380 { before(grammarAccess.getAggregationAccess().getLocalVariablesAssignment_1()); } 7307 { before(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); }
6381 (rule__Aggregation__LocalVariablesAssignment_1)? 7308 ruleExpression
6382 { after(grammarAccess.getAggregationAccess().getLocalVariablesAssignment_1()); } 7309 { after(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); }
6383) 7310)
6384; 7311;
6385finally { 7312finally {
6386 restoreStackSize(stackSize); 7313 restoreStackSize(stackSize);
6387} 7314}
6388 7315
6389rule__Aggregation__Group__2 7316rule__AtomicExpression__Group_4__2
6390 @init { 7317 @init {
6391 int stackSize = keepStackSize(); 7318 int stackSize = keepStackSize();
6392 } 7319 }
6393: 7320:
6394 rule__Aggregation__Group__2__Impl 7321 rule__AtomicExpression__Group_4__2__Impl
6395 rule__Aggregation__Group__3
6396; 7322;
6397finally { 7323finally {
6398 restoreStackSize(stackSize); 7324 restoreStackSize(stackSize);
6399} 7325}
6400 7326
6401rule__Aggregation__Group__2__Impl 7327rule__AtomicExpression__Group_4__2__Impl
6402 @init { 7328 @init {
6403 int stackSize = keepStackSize(); 7329 int stackSize = keepStackSize();
6404 } 7330 }
6405: 7331:
6406( 7332(
6407 { before(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_2()); } 7333 { before(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); }
6408 LeftCurlyBracket 7334 RightParenthesis
6409 { after(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_2()); } 7335 { after(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); }
6410) 7336)
6411; 7337;
6412finally { 7338finally {
6413 restoreStackSize(stackSize); 7339 restoreStackSize(stackSize);
6414} 7340}
6415 7341
6416rule__Aggregation__Group__3
6417 @init {
6418 int stackSize = keepStackSize();
6419 }
6420:
6421 rule__Aggregation__Group__3__Impl
6422 rule__Aggregation__Group__4
6423;
6424finally {
6425 restoreStackSize(stackSize);
6426}
6427
6428rule__Aggregation__Group__3__Impl
6429 @init {
6430 int stackSize = keepStackSize();
6431 }
6432:
6433(
6434 { before(grammarAccess.getAggregationAccess().getBodyAssignment_3()); }
6435 (rule__Aggregation__BodyAssignment_3)
6436 { after(grammarAccess.getAggregationAccess().getBodyAssignment_3()); }
6437)
6438;
6439finally {
6440 restoreStackSize(stackSize);
6441}
6442 7342
6443rule__Aggregation__Group__4 7343rule__Call__Group__0
6444 @init { 7344 @init {
6445 int stackSize = keepStackSize(); 7345 int stackSize = keepStackSize();
6446 } 7346 }
6447: 7347:
6448 rule__Aggregation__Group__4__Impl 7348 rule__Call__Group__0__Impl
6449 rule__Aggregation__Group__5 7349 rule__Call__Group__1
6450; 7350;
6451finally { 7351finally {
6452 restoreStackSize(stackSize); 7352 restoreStackSize(stackSize);
6453} 7353}
6454 7354
6455rule__Aggregation__Group__4__Impl 7355rule__Call__Group__0__Impl
6456 @init { 7356 @init {
6457 int stackSize = keepStackSize(); 7357 int stackSize = keepStackSize();
6458 } 7358 }
6459: 7359:
6460( 7360(
6461 { before(grammarAccess.getAggregationAccess().getGroup_4()); } 7361 { before(grammarAccess.getCallAccess().getFunctorAssignment_0()); }
6462 (rule__Aggregation__Group_4__0)? 7362 (rule__Call__FunctorAssignment_0)
6463 { after(grammarAccess.getAggregationAccess().getGroup_4()); } 7363 { after(grammarAccess.getCallAccess().getFunctorAssignment_0()); }
6464) 7364)
6465; 7365;
6466finally { 7366finally {
6467 restoreStackSize(stackSize); 7367 restoreStackSize(stackSize);
6468} 7368}
6469 7369
6470rule__Aggregation__Group__5 7370rule__Call__Group__1
6471 @init { 7371 @init {
6472 int stackSize = keepStackSize(); 7372 int stackSize = keepStackSize();
6473 } 7373 }
6474: 7374:
6475 rule__Aggregation__Group__5__Impl 7375 rule__Call__Group__1__Impl
6476; 7376;
6477finally { 7377finally {
6478 restoreStackSize(stackSize); 7378 restoreStackSize(stackSize);
6479} 7379}
6480 7380
6481rule__Aggregation__Group__5__Impl 7381rule__Call__Group__1__Impl
6482 @init { 7382 @init {
6483 int stackSize = keepStackSize(); 7383 int stackSize = keepStackSize();
6484 } 7384 }
6485: 7385:
6486( 7386(
6487 { before(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); } 7387 { before(grammarAccess.getCallAccess().getArgumentListAssignment_1()); }
6488 RightCurlyBracket 7388 (rule__Call__ArgumentListAssignment_1)
6489 { after(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); } 7389 { after(grammarAccess.getCallAccess().getArgumentListAssignment_1()); }
6490) 7390)
6491; 7391;
6492finally { 7392finally {
@@ -6494,215 +7394,215 @@ finally {
6494} 7394}
6495 7395
6496 7396
6497rule__Aggregation__Group_4__0 7397rule__ArgumentList__Group__0
6498 @init { 7398 @init {
6499 int stackSize = keepStackSize(); 7399 int stackSize = keepStackSize();
6500 } 7400 }
6501: 7401:
6502 rule__Aggregation__Group_4__0__Impl 7402 rule__ArgumentList__Group__0__Impl
6503 rule__Aggregation__Group_4__1 7403 rule__ArgumentList__Group__1
6504; 7404;
6505finally { 7405finally {
6506 restoreStackSize(stackSize); 7406 restoreStackSize(stackSize);
6507} 7407}
6508 7408
6509rule__Aggregation__Group_4__0__Impl 7409rule__ArgumentList__Group__0__Impl
6510 @init { 7410 @init {
6511 int stackSize = keepStackSize(); 7411 int stackSize = keepStackSize();
6512 } 7412 }
6513: 7413:
6514( 7414(
6515 { before(grammarAccess.getAggregationAccess().getVerticalLineKeyword_4_0()); } 7415 { before(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); }
6516 VerticalLine 7416 ()
6517 { after(grammarAccess.getAggregationAccess().getVerticalLineKeyword_4_0()); } 7417 { after(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); }
6518) 7418)
6519; 7419;
6520finally { 7420finally {
6521 restoreStackSize(stackSize); 7421 restoreStackSize(stackSize);
6522} 7422}
6523 7423
6524rule__Aggregation__Group_4__1 7424rule__ArgumentList__Group__1
6525 @init { 7425 @init {
6526 int stackSize = keepStackSize(); 7426 int stackSize = keepStackSize();
6527 } 7427 }
6528: 7428:
6529 rule__Aggregation__Group_4__1__Impl 7429 rule__ArgumentList__Group__1__Impl
7430 rule__ArgumentList__Group__2
6530; 7431;
6531finally { 7432finally {
6532 restoreStackSize(stackSize); 7433 restoreStackSize(stackSize);
6533} 7434}
6534 7435
6535rule__Aggregation__Group_4__1__Impl 7436rule__ArgumentList__Group__1__Impl
6536 @init { 7437 @init {
6537 int stackSize = keepStackSize(); 7438 int stackSize = keepStackSize();
6538 } 7439 }
6539: 7440:
6540( 7441(
6541 { before(grammarAccess.getAggregationAccess().getConditionAssignment_4_1()); } 7442 { before(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); }
6542 (rule__Aggregation__ConditionAssignment_4_1) 7443 LeftParenthesis
6543 { after(grammarAccess.getAggregationAccess().getConditionAssignment_4_1()); } 7444 { after(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); }
6544) 7445)
6545; 7446;
6546finally { 7447finally {
6547 restoreStackSize(stackSize); 7448 restoreStackSize(stackSize);
6548} 7449}
6549 7450
6550 7451rule__ArgumentList__Group__2
6551rule__AtomicExpression__Group_4__0
6552 @init { 7452 @init {
6553 int stackSize = keepStackSize(); 7453 int stackSize = keepStackSize();
6554 } 7454 }
6555: 7455:
6556 rule__AtomicExpression__Group_4__0__Impl 7456 rule__ArgumentList__Group__2__Impl
6557 rule__AtomicExpression__Group_4__1 7457 rule__ArgumentList__Group__3
6558; 7458;
6559finally { 7459finally {
6560 restoreStackSize(stackSize); 7460 restoreStackSize(stackSize);
6561} 7461}
6562 7462
6563rule__AtomicExpression__Group_4__0__Impl 7463rule__ArgumentList__Group__2__Impl
6564 @init { 7464 @init {
6565 int stackSize = keepStackSize(); 7465 int stackSize = keepStackSize();
6566 } 7466 }
6567: 7467:
6568( 7468(
6569 { before(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); } 7469 { before(grammarAccess.getArgumentListAccess().getGroup_2()); }
6570 LeftParenthesis 7470 (rule__ArgumentList__Group_2__0)?
6571 { after(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); } 7471 { after(grammarAccess.getArgumentListAccess().getGroup_2()); }
6572) 7472)
6573; 7473;
6574finally { 7474finally {
6575 restoreStackSize(stackSize); 7475 restoreStackSize(stackSize);
6576} 7476}
6577 7477
6578rule__AtomicExpression__Group_4__1 7478rule__ArgumentList__Group__3
6579 @init { 7479 @init {
6580 int stackSize = keepStackSize(); 7480 int stackSize = keepStackSize();
6581 } 7481 }
6582: 7482:
6583 rule__AtomicExpression__Group_4__1__Impl 7483 rule__ArgumentList__Group__3__Impl
6584 rule__AtomicExpression__Group_4__2
6585; 7484;
6586finally { 7485finally {
6587 restoreStackSize(stackSize); 7486 restoreStackSize(stackSize);
6588} 7487}
6589 7488
6590rule__AtomicExpression__Group_4__1__Impl 7489rule__ArgumentList__Group__3__Impl
6591 @init { 7490 @init {
6592 int stackSize = keepStackSize(); 7491 int stackSize = keepStackSize();
6593 } 7492 }
6594: 7493:
6595( 7494(
6596 { before(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); } 7495 { before(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); }
6597 ruleExpression 7496 RightParenthesis
6598 { after(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); } 7497 { after(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); }
6599) 7498)
6600; 7499;
6601finally { 7500finally {
6602 restoreStackSize(stackSize); 7501 restoreStackSize(stackSize);
6603} 7502}
6604 7503
6605rule__AtomicExpression__Group_4__2 7504
7505rule__ArgumentList__Group_2__0
6606 @init { 7506 @init {
6607 int stackSize = keepStackSize(); 7507 int stackSize = keepStackSize();
6608 } 7508 }
6609: 7509:
6610 rule__AtomicExpression__Group_4__2__Impl 7510 rule__ArgumentList__Group_2__0__Impl
7511 rule__ArgumentList__Group_2__1
6611; 7512;
6612finally { 7513finally {
6613 restoreStackSize(stackSize); 7514 restoreStackSize(stackSize);
6614} 7515}
6615 7516
6616rule__AtomicExpression__Group_4__2__Impl 7517rule__ArgumentList__Group_2__0__Impl
6617 @init { 7518 @init {
6618 int stackSize = keepStackSize(); 7519 int stackSize = keepStackSize();
6619 } 7520 }
6620: 7521:
6621( 7522(
6622 { before(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); } 7523 { before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); }
6623 RightParenthesis 7524 (rule__ArgumentList__ArgumentsAssignment_2_0)
6624 { after(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); } 7525 { after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); }
6625) 7526)
6626; 7527;
6627finally { 7528finally {
6628 restoreStackSize(stackSize); 7529 restoreStackSize(stackSize);
6629} 7530}
6630 7531
6631 7532rule__ArgumentList__Group_2__1
6632rule__Call__Group__0
6633 @init { 7533 @init {
6634 int stackSize = keepStackSize(); 7534 int stackSize = keepStackSize();
6635 } 7535 }
6636: 7536:
6637 rule__Call__Group__0__Impl 7537 rule__ArgumentList__Group_2__1__Impl
6638 rule__Call__Group__1
6639; 7538;
6640finally { 7539finally {
6641 restoreStackSize(stackSize); 7540 restoreStackSize(stackSize);
6642} 7541}
6643 7542
6644rule__Call__Group__0__Impl 7543rule__ArgumentList__Group_2__1__Impl
6645 @init { 7544 @init {
6646 int stackSize = keepStackSize(); 7545 int stackSize = keepStackSize();
6647 } 7546 }
6648: 7547:
6649( 7548(
6650 { before(grammarAccess.getCallAccess().getFunctorAssignment_0()); } 7549 { before(grammarAccess.getArgumentListAccess().getGroup_2_1()); }
6651 (rule__Call__FunctorAssignment_0) 7550 (rule__ArgumentList__Group_2_1__0)*
6652 { after(grammarAccess.getCallAccess().getFunctorAssignment_0()); } 7551 { after(grammarAccess.getArgumentListAccess().getGroup_2_1()); }
6653) 7552)
6654; 7553;
6655finally { 7554finally {
6656 restoreStackSize(stackSize); 7555 restoreStackSize(stackSize);
6657} 7556}
6658 7557
6659rule__Call__Group__1 7558
7559rule__ArgumentList__Group_2_1__0
6660 @init { 7560 @init {
6661 int stackSize = keepStackSize(); 7561 int stackSize = keepStackSize();
6662 } 7562 }
6663: 7563:
6664 rule__Call__Group__1__Impl 7564 rule__ArgumentList__Group_2_1__0__Impl
6665 rule__Call__Group__2 7565 rule__ArgumentList__Group_2_1__1
6666; 7566;
6667finally { 7567finally {
6668 restoreStackSize(stackSize); 7568 restoreStackSize(stackSize);
6669} 7569}
6670 7570
6671rule__Call__Group__1__Impl 7571rule__ArgumentList__Group_2_1__0__Impl
6672 @init { 7572 @init {
6673 int stackSize = keepStackSize(); 7573 int stackSize = keepStackSize();
6674 } 7574 }
6675: 7575:
6676( 7576(
6677 { before(grammarAccess.getCallAccess().getAlternatives_1()); } 7577 { before(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); }
6678 (rule__Call__Alternatives_1)? 7578 Comma
6679 { after(grammarAccess.getCallAccess().getAlternatives_1()); } 7579 { after(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); }
6680) 7580)
6681; 7581;
6682finally { 7582finally {
6683 restoreStackSize(stackSize); 7583 restoreStackSize(stackSize);
6684} 7584}
6685 7585
6686rule__Call__Group__2 7586rule__ArgumentList__Group_2_1__1
6687 @init { 7587 @init {
6688 int stackSize = keepStackSize(); 7588 int stackSize = keepStackSize();
6689 } 7589 }
6690: 7590:
6691 rule__Call__Group__2__Impl 7591 rule__ArgumentList__Group_2_1__1__Impl
6692; 7592;
6693finally { 7593finally {
6694 restoreStackSize(stackSize); 7594 restoreStackSize(stackSize);
6695} 7595}
6696 7596
6697rule__Call__Group__2__Impl 7597rule__ArgumentList__Group_2_1__1__Impl
6698 @init { 7598 @init {
6699 int stackSize = keepStackSize(); 7599 int stackSize = keepStackSize();
6700 } 7600 }
6701: 7601:
6702( 7602(
6703 { before(grammarAccess.getCallAccess().getArgumentListAssignment_2()); } 7603 { before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); }
6704 (rule__Call__ArgumentListAssignment_2) 7604 (rule__ArgumentList__ArgumentsAssignment_2_1_1)
6705 { after(grammarAccess.getCallAccess().getArgumentListAssignment_2()); } 7605 { after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); }
6706) 7606)
6707; 7607;
6708finally { 7608finally {
@@ -6710,107 +7610,107 @@ finally {
6710} 7610}
6711 7611
6712 7612
6713rule__ArgumentList__Group__0 7613rule__StarArgument__Group__0
6714 @init { 7614 @init {
6715 int stackSize = keepStackSize(); 7615 int stackSize = keepStackSize();
6716 } 7616 }
6717: 7617:
6718 rule__ArgumentList__Group__0__Impl 7618 rule__StarArgument__Group__0__Impl
6719 rule__ArgumentList__Group__1 7619 rule__StarArgument__Group__1
6720; 7620;
6721finally { 7621finally {
6722 restoreStackSize(stackSize); 7622 restoreStackSize(stackSize);
6723} 7623}
6724 7624
6725rule__ArgumentList__Group__0__Impl 7625rule__StarArgument__Group__0__Impl
6726 @init { 7626 @init {
6727 int stackSize = keepStackSize(); 7627 int stackSize = keepStackSize();
6728 } 7628 }
6729: 7629:
6730( 7630(
6731 { before(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); } 7631 { before(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); }
6732 () 7632 ()
6733 { after(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); } 7633 { after(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); }
6734) 7634)
6735; 7635;
6736finally { 7636finally {
6737 restoreStackSize(stackSize); 7637 restoreStackSize(stackSize);
6738} 7638}
6739 7639
6740rule__ArgumentList__Group__1 7640rule__StarArgument__Group__1
6741 @init { 7641 @init {
6742 int stackSize = keepStackSize(); 7642 int stackSize = keepStackSize();
6743 } 7643 }
6744: 7644:
6745 rule__ArgumentList__Group__1__Impl 7645 rule__StarArgument__Group__1__Impl
6746 rule__ArgumentList__Group__2
6747; 7646;
6748finally { 7647finally {
6749 restoreStackSize(stackSize); 7648 restoreStackSize(stackSize);
6750} 7649}
6751 7650
6752rule__ArgumentList__Group__1__Impl 7651rule__StarArgument__Group__1__Impl
6753 @init { 7652 @init {
6754 int stackSize = keepStackSize(); 7653 int stackSize = keepStackSize();
6755 } 7654 }
6756: 7655:
6757( 7656(
6758 { before(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); } 7657 { before(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); }
6759 LeftParenthesis 7658 Asterisk
6760 { after(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); } 7659 { after(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); }
6761) 7660)
6762; 7661;
6763finally { 7662finally {
6764 restoreStackSize(stackSize); 7663 restoreStackSize(stackSize);
6765} 7664}
6766 7665
6767rule__ArgumentList__Group__2 7666
7667rule__TypedVariableArgument__Group__0
6768 @init { 7668 @init {
6769 int stackSize = keepStackSize(); 7669 int stackSize = keepStackSize();
6770 } 7670 }
6771: 7671:
6772 rule__ArgumentList__Group__2__Impl 7672 rule__TypedVariableArgument__Group__0__Impl
6773 rule__ArgumentList__Group__3 7673 rule__TypedVariableArgument__Group__1
6774; 7674;
6775finally { 7675finally {
6776 restoreStackSize(stackSize); 7676 restoreStackSize(stackSize);
6777} 7677}
6778 7678
6779rule__ArgumentList__Group__2__Impl 7679rule__TypedVariableArgument__Group__0__Impl
6780 @init { 7680 @init {
6781 int stackSize = keepStackSize(); 7681 int stackSize = keepStackSize();
6782 } 7682 }
6783: 7683:
6784( 7684(
6785 { before(grammarAccess.getArgumentListAccess().getGroup_2()); } 7685 { before(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceAssignment_0()); }
6786 (rule__ArgumentList__Group_2__0)? 7686 (rule__TypedVariableArgument__TypeReferenceAssignment_0)
6787 { after(grammarAccess.getArgumentListAccess().getGroup_2()); } 7687 { after(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceAssignment_0()); }
6788) 7688)
6789; 7689;
6790finally { 7690finally {
6791 restoreStackSize(stackSize); 7691 restoreStackSize(stackSize);
6792} 7692}
6793 7693
6794rule__ArgumentList__Group__3 7694rule__TypedVariableArgument__Group__1
6795 @init { 7695 @init {
6796 int stackSize = keepStackSize(); 7696 int stackSize = keepStackSize();
6797 } 7697 }
6798: 7698:
6799 rule__ArgumentList__Group__3__Impl 7699 rule__TypedVariableArgument__Group__1__Impl
6800; 7700;
6801finally { 7701finally {
6802 restoreStackSize(stackSize); 7702 restoreStackSize(stackSize);
6803} 7703}
6804 7704
6805rule__ArgumentList__Group__3__Impl 7705rule__TypedVariableArgument__Group__1__Impl
6806 @init { 7706 @init {
6807 int stackSize = keepStackSize(); 7707 int stackSize = keepStackSize();
6808 } 7708 }
6809: 7709:
6810( 7710(
6811 { before(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); } 7711 { before(grammarAccess.getTypedVariableArgumentAccess().getNameAssignment_1()); }
6812 RightParenthesis 7712 (rule__TypedVariableArgument__NameAssignment_1)
6813 { after(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); } 7713 { after(grammarAccess.getTypedVariableArgumentAccess().getNameAssignment_1()); }
6814) 7714)
6815; 7715;
6816finally { 7716finally {
@@ -6818,53 +7718,53 @@ finally {
6818} 7718}
6819 7719
6820 7720
6821rule__ArgumentList__Group_2__0 7721rule__TypedStarArgument__Group__0
6822 @init { 7722 @init {
6823 int stackSize = keepStackSize(); 7723 int stackSize = keepStackSize();
6824 } 7724 }
6825: 7725:
6826 rule__ArgumentList__Group_2__0__Impl 7726 rule__TypedStarArgument__Group__0__Impl
6827 rule__ArgumentList__Group_2__1 7727 rule__TypedStarArgument__Group__1
6828; 7728;
6829finally { 7729finally {
6830 restoreStackSize(stackSize); 7730 restoreStackSize(stackSize);
6831} 7731}
6832 7732
6833rule__ArgumentList__Group_2__0__Impl 7733rule__TypedStarArgument__Group__0__Impl
6834 @init { 7734 @init {
6835 int stackSize = keepStackSize(); 7735 int stackSize = keepStackSize();
6836 } 7736 }
6837: 7737:
6838( 7738(
6839 { before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); } 7739 { before(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceAssignment_0()); }
6840 (rule__ArgumentList__ArgumentsAssignment_2_0) 7740 (rule__TypedStarArgument__TypeReferenceAssignment_0)
6841 { after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); } 7741 { after(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceAssignment_0()); }
6842) 7742)
6843; 7743;
6844finally { 7744finally {
6845 restoreStackSize(stackSize); 7745 restoreStackSize(stackSize);
6846} 7746}
6847 7747
6848rule__ArgumentList__Group_2__1 7748rule__TypedStarArgument__Group__1
6849 @init { 7749 @init {
6850 int stackSize = keepStackSize(); 7750 int stackSize = keepStackSize();
6851 } 7751 }
6852: 7752:
6853 rule__ArgumentList__Group_2__1__Impl 7753 rule__TypedStarArgument__Group__1__Impl
6854; 7754;
6855finally { 7755finally {
6856 restoreStackSize(stackSize); 7756 restoreStackSize(stackSize);
6857} 7757}
6858 7758
6859rule__ArgumentList__Group_2__1__Impl 7759rule__TypedStarArgument__Group__1__Impl
6860 @init { 7760 @init {
6861 int stackSize = keepStackSize(); 7761 int stackSize = keepStackSize();
6862 } 7762 }
6863: 7763:
6864( 7764(
6865 { before(grammarAccess.getArgumentListAccess().getGroup_2_1()); } 7765 { before(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); }
6866 (rule__ArgumentList__Group_2_1__0)* 7766 Asterisk
6867 { after(grammarAccess.getArgumentListAccess().getGroup_2_1()); } 7767 { after(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); }
6868) 7768)
6869; 7769;
6870finally { 7770finally {
@@ -6872,53 +7772,53 @@ finally {
6872} 7772}
6873 7773
6874 7774
6875rule__ArgumentList__Group_2_1__0 7775rule__Reference__Group__0
6876 @init { 7776 @init {
6877 int stackSize = keepStackSize(); 7777 int stackSize = keepStackSize();
6878 } 7778 }
6879: 7779:
6880 rule__ArgumentList__Group_2_1__0__Impl 7780 rule__Reference__Group__0__Impl
6881 rule__ArgumentList__Group_2_1__1 7781 rule__Reference__Group__1
6882; 7782;
6883finally { 7783finally {
6884 restoreStackSize(stackSize); 7784 restoreStackSize(stackSize);
6885} 7785}
6886 7786
6887rule__ArgumentList__Group_2_1__0__Impl 7787rule__Reference__Group__0__Impl
6888 @init { 7788 @init {
6889 int stackSize = keepStackSize(); 7789 int stackSize = keepStackSize();
6890 } 7790 }
6891: 7791:
6892( 7792(
6893 { before(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); } 7793 { before(grammarAccess.getReferenceAccess().getComponentsAssignment_0()); }
6894 Comma 7794 (rule__Reference__ComponentsAssignment_0)
6895 { after(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); } 7795 { after(grammarAccess.getReferenceAccess().getComponentsAssignment_0()); }
6896) 7796)
6897; 7797;
6898finally { 7798finally {
6899 restoreStackSize(stackSize); 7799 restoreStackSize(stackSize);
6900} 7800}
6901 7801
6902rule__ArgumentList__Group_2_1__1 7802rule__Reference__Group__1
6903 @init { 7803 @init {
6904 int stackSize = keepStackSize(); 7804 int stackSize = keepStackSize();
6905 } 7805 }
6906: 7806:
6907 rule__ArgumentList__Group_2_1__1__Impl 7807 rule__Reference__Group__1__Impl
6908; 7808;
6909finally { 7809finally {
6910 restoreStackSize(stackSize); 7810 restoreStackSize(stackSize);
6911} 7811}
6912 7812
6913rule__ArgumentList__Group_2_1__1__Impl 7813rule__Reference__Group__1__Impl
6914 @init { 7814 @init {
6915 int stackSize = keepStackSize(); 7815 int stackSize = keepStackSize();
6916 } 7816 }
6917: 7817:
6918( 7818(
6919 { before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); } 7819 { before(grammarAccess.getReferenceAccess().getGroup_1()); }
6920 (rule__ArgumentList__ArgumentsAssignment_2_1_1) 7820 (rule__Reference__Group_1__0)*
6921 { after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); } 7821 { after(grammarAccess.getReferenceAccess().getGroup_1()); }
6922) 7822)
6923; 7823;
6924finally { 7824finally {
@@ -6926,53 +7826,53 @@ finally {
6926} 7826}
6927 7827
6928 7828
6929rule__StarArgument__Group__0 7829rule__Reference__Group_1__0
6930 @init { 7830 @init {
6931 int stackSize = keepStackSize(); 7831 int stackSize = keepStackSize();
6932 } 7832 }
6933: 7833:
6934 rule__StarArgument__Group__0__Impl 7834 rule__Reference__Group_1__0__Impl
6935 rule__StarArgument__Group__1 7835 rule__Reference__Group_1__1
6936; 7836;
6937finally { 7837finally {
6938 restoreStackSize(stackSize); 7838 restoreStackSize(stackSize);
6939} 7839}
6940 7840
6941rule__StarArgument__Group__0__Impl 7841rule__Reference__Group_1__0__Impl
6942 @init { 7842 @init {
6943 int stackSize = keepStackSize(); 7843 int stackSize = keepStackSize();
6944 } 7844 }
6945: 7845:
6946( 7846(
6947 { before(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); } 7847 { before(grammarAccess.getReferenceAccess().getFullStopKeyword_1_0()); }
6948 () 7848 FullStop
6949 { after(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); } 7849 { after(grammarAccess.getReferenceAccess().getFullStopKeyword_1_0()); }
6950) 7850)
6951; 7851;
6952finally { 7852finally {
6953 restoreStackSize(stackSize); 7853 restoreStackSize(stackSize);
6954} 7854}
6955 7855
6956rule__StarArgument__Group__1 7856rule__Reference__Group_1__1
6957 @init { 7857 @init {
6958 int stackSize = keepStackSize(); 7858 int stackSize = keepStackSize();
6959 } 7859 }
6960: 7860:
6961 rule__StarArgument__Group__1__Impl 7861 rule__Reference__Group_1__1__Impl
6962; 7862;
6963finally { 7863finally {
6964 restoreStackSize(stackSize); 7864 restoreStackSize(stackSize);
6965} 7865}
6966 7866
6967rule__StarArgument__Group__1__Impl 7867rule__Reference__Group_1__1__Impl
6968 @init { 7868 @init {
6969 int stackSize = keepStackSize(); 7869 int stackSize = keepStackSize();
6970 } 7870 }
6971: 7871:
6972( 7872(
6973 { before(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); } 7873 { before(grammarAccess.getReferenceAccess().getComponentsAssignment_1_1()); }
6974 Asterisk 7874 (rule__Reference__ComponentsAssignment_1_1)
6975 { after(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); } 7875 { after(grammarAccess.getReferenceAccess().getComponentsAssignment_1_1()); }
6976) 7876)
6977; 7877;
6978finally { 7878finally {
@@ -6980,107 +7880,80 @@ finally {
6980} 7880}
6981 7881
6982 7882
6983rule__TypedArgument__Group__0 7883rule__PathComponent__Group__0
6984 @init {
6985 int stackSize = keepStackSize();
6986 }
6987:
6988 rule__TypedArgument__Group__0__Impl
6989 rule__TypedArgument__Group__1
6990;
6991finally {
6992 restoreStackSize(stackSize);
6993}
6994
6995rule__TypedArgument__Group__0__Impl
6996 @init {
6997 int stackSize = keepStackSize();
6998 }
6999:
7000(
7001 { before(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); }
7002 (rule__TypedArgument__TypeAssignment_0)
7003 { after(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); }
7004)
7005;
7006finally {
7007 restoreStackSize(stackSize);
7008}
7009
7010rule__TypedArgument__Group__1
7011 @init { 7884 @init {
7012 int stackSize = keepStackSize(); 7885 int stackSize = keepStackSize();
7013 } 7886 }
7014: 7887:
7015 rule__TypedArgument__Group__1__Impl 7888 rule__PathComponent__Group__0__Impl
7889 rule__PathComponent__Group__1
7016; 7890;
7017finally { 7891finally {
7018 restoreStackSize(stackSize); 7892 restoreStackSize(stackSize);
7019} 7893}
7020 7894
7021rule__TypedArgument__Group__1__Impl 7895rule__PathComponent__Group__0__Impl
7022 @init { 7896 @init {
7023 int stackSize = keepStackSize(); 7897 int stackSize = keepStackSize();
7024 } 7898 }
7025: 7899:
7026( 7900(
7027 { before(grammarAccess.getTypedArgumentAccess().getVariableAssignment_1()); } 7901 { before(grammarAccess.getPathComponentAccess().getInverseAssignment_0()); }
7028 (rule__TypedArgument__VariableAssignment_1) 7902 (rule__PathComponent__InverseAssignment_0)?
7029 { after(grammarAccess.getTypedArgumentAccess().getVariableAssignment_1()); } 7903 { after(grammarAccess.getPathComponentAccess().getInverseAssignment_0()); }
7030) 7904)
7031; 7905;
7032finally { 7906finally {
7033 restoreStackSize(stackSize); 7907 restoreStackSize(stackSize);
7034} 7908}
7035 7909
7036 7910rule__PathComponent__Group__1
7037rule__TypedStarArgument__Group__0
7038 @init { 7911 @init {
7039 int stackSize = keepStackSize(); 7912 int stackSize = keepStackSize();
7040 } 7913 }
7041: 7914:
7042 rule__TypedStarArgument__Group__0__Impl 7915 rule__PathComponent__Group__1__Impl
7043 rule__TypedStarArgument__Group__1 7916 rule__PathComponent__Group__2
7044; 7917;
7045finally { 7918finally {
7046 restoreStackSize(stackSize); 7919 restoreStackSize(stackSize);
7047} 7920}
7048 7921
7049rule__TypedStarArgument__Group__0__Impl 7922rule__PathComponent__Group__1__Impl
7050 @init { 7923 @init {
7051 int stackSize = keepStackSize(); 7924 int stackSize = keepStackSize();
7052 } 7925 }
7053: 7926:
7054( 7927(
7055 { before(grammarAccess.getTypedStarArgumentAccess().getTypeAssignment_0()); } 7928 { before(grammarAccess.getPathComponentAccess().getSymbolAssignment_1()); }
7056 (rule__TypedStarArgument__TypeAssignment_0) 7929 (rule__PathComponent__SymbolAssignment_1)
7057 { after(grammarAccess.getTypedStarArgumentAccess().getTypeAssignment_0()); } 7930 { after(grammarAccess.getPathComponentAccess().getSymbolAssignment_1()); }
7058) 7931)
7059; 7932;
7060finally { 7933finally {
7061 restoreStackSize(stackSize); 7934 restoreStackSize(stackSize);
7062} 7935}
7063 7936
7064rule__TypedStarArgument__Group__1 7937rule__PathComponent__Group__2
7065 @init { 7938 @init {
7066 int stackSize = keepStackSize(); 7939 int stackSize = keepStackSize();
7067 } 7940 }
7068: 7941:
7069 rule__TypedStarArgument__Group__1__Impl 7942 rule__PathComponent__Group__2__Impl
7070; 7943;
7071finally { 7944finally {
7072 restoreStackSize(stackSize); 7945 restoreStackSize(stackSize);
7073} 7946}
7074 7947
7075rule__TypedStarArgument__Group__1__Impl 7948rule__PathComponent__Group__2__Impl
7076 @init { 7949 @init {
7077 int stackSize = keepStackSize(); 7950 int stackSize = keepStackSize();
7078 } 7951 }
7079: 7952:
7080( 7953(
7081 { before(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); } 7954 { before(grammarAccess.getPathComponentAccess().getAlternatives_2()); }
7082 Asterisk 7955 (rule__PathComponent__Alternatives_2)?
7083 { after(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); } 7956 { after(grammarAccess.getPathComponentAccess().getAlternatives_2()); }
7084) 7957)
7085; 7958;
7086finally { 7959finally {
@@ -7160,9 +8033,9 @@ rule__Interval__Group__2__Impl
7160 } 8033 }
7161: 8034:
7162( 8035(
7163 { before(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); } 8036 { before(grammarAccess.getIntervalAccess().getCommaKeyword_2()); }
7164 FullStopFullStop 8037 Comma
7165 { after(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); } 8038 { after(grammarAccess.getIntervalAccess().getCommaKeyword_2()); }
7166) 8039)
7167; 8040;
7168finally { 8041finally {
@@ -7277,53 +8150,53 @@ finally {
7277} 8150}
7278 8151
7279 8152
7280rule__EmptyIntervalLiteral__Group__0 8153rule__EmptyLiteral__Group__0
7281 @init { 8154 @init {
7282 int stackSize = keepStackSize(); 8155 int stackSize = keepStackSize();
7283 } 8156 }
7284: 8157:
7285 rule__EmptyIntervalLiteral__Group__0__Impl 8158 rule__EmptyLiteral__Group__0__Impl
7286 rule__EmptyIntervalLiteral__Group__1 8159 rule__EmptyLiteral__Group__1
7287; 8160;
7288finally { 8161finally {
7289 restoreStackSize(stackSize); 8162 restoreStackSize(stackSize);
7290} 8163}
7291 8164
7292rule__EmptyIntervalLiteral__Group__0__Impl 8165rule__EmptyLiteral__Group__0__Impl
7293 @init { 8166 @init {
7294 int stackSize = keepStackSize(); 8167 int stackSize = keepStackSize();
7295 } 8168 }
7296: 8169:
7297( 8170(
7298 { before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); } 8171 { before(grammarAccess.getEmptyLiteralAccess().getEmptyLiteralAction_0()); }
7299 () 8172 ()
7300 { after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); } 8173 { after(grammarAccess.getEmptyLiteralAccess().getEmptyLiteralAction_0()); }
7301) 8174)
7302; 8175;
7303finally { 8176finally {
7304 restoreStackSize(stackSize); 8177 restoreStackSize(stackSize);
7305} 8178}
7306 8179
7307rule__EmptyIntervalLiteral__Group__1 8180rule__EmptyLiteral__Group__1
7308 @init { 8181 @init {
7309 int stackSize = keepStackSize(); 8182 int stackSize = keepStackSize();
7310 } 8183 }
7311: 8184:
7312 rule__EmptyIntervalLiteral__Group__1__Impl 8185 rule__EmptyLiteral__Group__1__Impl
7313; 8186;
7314finally { 8187finally {
7315 restoreStackSize(stackSize); 8188 restoreStackSize(stackSize);
7316} 8189}
7317 8190
7318rule__EmptyIntervalLiteral__Group__1__Impl 8191rule__EmptyLiteral__Group__1__Impl
7319 @init { 8192 @init {
7320 int stackSize = keepStackSize(); 8193 int stackSize = keepStackSize();
7321 } 8194 }
7322: 8195:
7323( 8196(
7324 { before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); } 8197 { before(grammarAccess.getEmptyLiteralAccess().getEmptyKeyword_1()); }
7325 Empty 8198 Empty
7326 { after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); } 8199 { after(grammarAccess.getEmptyLiteralAccess().getEmptyKeyword_1()); }
7327) 8200)
7328; 8201;
7329finally { 8202finally {
@@ -7331,269 +8204,269 @@ finally {
7331} 8204}
7332 8205
7333 8206
7334rule__ClassDefinition__Group__0 8207rule__ClassDeclaration__Group__0
7335 @init { 8208 @init {
7336 int stackSize = keepStackSize(); 8209 int stackSize = keepStackSize();
7337 } 8210 }
7338: 8211:
7339 rule__ClassDefinition__Group__0__Impl 8212 rule__ClassDeclaration__Group__0__Impl
7340 rule__ClassDefinition__Group__1 8213 rule__ClassDeclaration__Group__1
7341; 8214;
7342finally { 8215finally {
7343 restoreStackSize(stackSize); 8216 restoreStackSize(stackSize);
7344} 8217}
7345 8218
7346rule__ClassDefinition__Group__0__Impl 8219rule__ClassDeclaration__Group__0__Impl
7347 @init { 8220 @init {
7348 int stackSize = keepStackSize(); 8221 int stackSize = keepStackSize();
7349 } 8222 }
7350: 8223:
7351( 8224(
7352 { before(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); } 8225 { before(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); }
7353 (rule__ClassDefinition__AbstractAssignment_0)? 8226 (rule__ClassDeclaration__UnorderedGroup_0)
7354 { after(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); } 8227 { after(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); }
7355) 8228)
7356; 8229;
7357finally { 8230finally {
7358 restoreStackSize(stackSize); 8231 restoreStackSize(stackSize);
7359} 8232}
7360 8233
7361rule__ClassDefinition__Group__1 8234rule__ClassDeclaration__Group__1
7362 @init { 8235 @init {
7363 int stackSize = keepStackSize(); 8236 int stackSize = keepStackSize();
7364 } 8237 }
7365: 8238:
7366 rule__ClassDefinition__Group__1__Impl 8239 rule__ClassDeclaration__Group__1__Impl
7367 rule__ClassDefinition__Group__2 8240 rule__ClassDeclaration__Group__2
7368; 8241;
7369finally { 8242finally {
7370 restoreStackSize(stackSize); 8243 restoreStackSize(stackSize);
7371} 8244}
7372 8245
7373rule__ClassDefinition__Group__1__Impl 8246rule__ClassDeclaration__Group__1__Impl
7374 @init { 8247 @init {
7375 int stackSize = keepStackSize(); 8248 int stackSize = keepStackSize();
7376 } 8249 }
7377: 8250:
7378( 8251(
7379 { before(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); } 8252 { before(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); }
7380 Class 8253 Class
7381 { after(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); } 8254 { after(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); }
7382) 8255)
7383; 8256;
7384finally { 8257finally {
7385 restoreStackSize(stackSize); 8258 restoreStackSize(stackSize);
7386} 8259}
7387 8260
7388rule__ClassDefinition__Group__2 8261rule__ClassDeclaration__Group__2
7389 @init { 8262 @init {
7390 int stackSize = keepStackSize(); 8263 int stackSize = keepStackSize();
7391 } 8264 }
7392: 8265:
7393 rule__ClassDefinition__Group__2__Impl 8266 rule__ClassDeclaration__Group__2__Impl
7394 rule__ClassDefinition__Group__3 8267 rule__ClassDeclaration__Group__3
7395; 8268;
7396finally { 8269finally {
7397 restoreStackSize(stackSize); 8270 restoreStackSize(stackSize);
7398} 8271}
7399 8272
7400rule__ClassDefinition__Group__2__Impl 8273rule__ClassDeclaration__Group__2__Impl
7401 @init { 8274 @init {
7402 int stackSize = keepStackSize(); 8275 int stackSize = keepStackSize();
7403 } 8276 }
7404: 8277:
7405( 8278(
7406 { before(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); } 8279 { before(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); }
7407 (rule__ClassDefinition__NameAssignment_2) 8280 (rule__ClassDeclaration__NameAssignment_2)
7408 { after(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); } 8281 { after(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); }
7409) 8282)
7410; 8283;
7411finally { 8284finally {
7412 restoreStackSize(stackSize); 8285 restoreStackSize(stackSize);
7413} 8286}
7414 8287
7415rule__ClassDefinition__Group__3 8288rule__ClassDeclaration__Group__3
7416 @init { 8289 @init {
7417 int stackSize = keepStackSize(); 8290 int stackSize = keepStackSize();
7418 } 8291 }
7419: 8292:
7420 rule__ClassDefinition__Group__3__Impl 8293 rule__ClassDeclaration__Group__3__Impl
7421 rule__ClassDefinition__Group__4 8294 rule__ClassDeclaration__Group__4
7422; 8295;
7423finally { 8296finally {
7424 restoreStackSize(stackSize); 8297 restoreStackSize(stackSize);
7425} 8298}
7426 8299
7427rule__ClassDefinition__Group__3__Impl 8300rule__ClassDeclaration__Group__3__Impl
7428 @init { 8301 @init {
7429 int stackSize = keepStackSize(); 8302 int stackSize = keepStackSize();
7430 } 8303 }
7431: 8304:
7432( 8305(
7433 { before(grammarAccess.getClassDefinitionAccess().getGroup_3()); } 8306 { before(grammarAccess.getClassDeclarationAccess().getGroup_3()); }
7434 (rule__ClassDefinition__Group_3__0)? 8307 (rule__ClassDeclaration__Group_3__0)?
7435 { after(grammarAccess.getClassDefinitionAccess().getGroup_3()); } 8308 { after(grammarAccess.getClassDeclarationAccess().getGroup_3()); }
7436) 8309)
7437; 8310;
7438finally { 8311finally {
7439 restoreStackSize(stackSize); 8312 restoreStackSize(stackSize);
7440} 8313}
7441 8314
7442rule__ClassDefinition__Group__4 8315rule__ClassDeclaration__Group__4
7443 @init { 8316 @init {
7444 int stackSize = keepStackSize(); 8317 int stackSize = keepStackSize();
7445 } 8318 }
7446: 8319:
7447 rule__ClassDefinition__Group__4__Impl 8320 rule__ClassDeclaration__Group__4__Impl
7448 rule__ClassDefinition__Group__5
7449; 8321;
7450finally { 8322finally {
7451 restoreStackSize(stackSize); 8323 restoreStackSize(stackSize);
7452} 8324}
7453 8325
7454rule__ClassDefinition__Group__4__Impl 8326rule__ClassDeclaration__Group__4__Impl
7455 @init { 8327 @init {
7456 int stackSize = keepStackSize(); 8328 int stackSize = keepStackSize();
7457 } 8329 }
7458: 8330:
7459( 8331(
7460 { before(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); } 8332 { before(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); }
7461 LeftCurlyBracket 8333 (rule__ClassDeclaration__Alternatives_4)
7462 { after(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); } 8334 { after(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); }
7463) 8335)
7464; 8336;
7465finally { 8337finally {
7466 restoreStackSize(stackSize); 8338 restoreStackSize(stackSize);
7467} 8339}
7468 8340
7469rule__ClassDefinition__Group__5 8341
8342rule__ClassDeclaration__Group_3__0
7470 @init { 8343 @init {
7471 int stackSize = keepStackSize(); 8344 int stackSize = keepStackSize();
7472 } 8345 }
7473: 8346:
7474 rule__ClassDefinition__Group__5__Impl 8347 rule__ClassDeclaration__Group_3__0__Impl
7475 rule__ClassDefinition__Group__6 8348 rule__ClassDeclaration__Group_3__1
7476; 8349;
7477finally { 8350finally {
7478 restoreStackSize(stackSize); 8351 restoreStackSize(stackSize);
7479} 8352}
7480 8353
7481rule__ClassDefinition__Group__5__Impl 8354rule__ClassDeclaration__Group_3__0__Impl
7482 @init { 8355 @init {
7483 int stackSize = keepStackSize(); 8356 int stackSize = keepStackSize();
7484 } 8357 }
7485: 8358:
7486( 8359(
7487 { before(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); } 8360 { before(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); }
7488 (rule__ClassDefinition__MembersAssignment_5)* 8361 Extends
7489 { after(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); } 8362 { after(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); }
7490) 8363)
7491; 8364;
7492finally { 8365finally {
7493 restoreStackSize(stackSize); 8366 restoreStackSize(stackSize);
7494} 8367}
7495 8368
7496rule__ClassDefinition__Group__6 8369rule__ClassDeclaration__Group_3__1
7497 @init { 8370 @init {
7498 int stackSize = keepStackSize(); 8371 int stackSize = keepStackSize();
7499 } 8372 }
7500: 8373:
7501 rule__ClassDefinition__Group__6__Impl 8374 rule__ClassDeclaration__Group_3__1__Impl
8375 rule__ClassDeclaration__Group_3__2
7502; 8376;
7503finally { 8377finally {
7504 restoreStackSize(stackSize); 8378 restoreStackSize(stackSize);
7505} 8379}
7506 8380
7507rule__ClassDefinition__Group__6__Impl 8381rule__ClassDeclaration__Group_3__1__Impl
7508 @init { 8382 @init {
7509 int stackSize = keepStackSize(); 8383 int stackSize = keepStackSize();
7510 } 8384 }
7511: 8385:
7512( 8386(
7513 { before(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); } 8387 { before(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_1()); }
7514 RightCurlyBracket 8388 (rule__ClassDeclaration__SupertypesAssignment_3_1)
7515 { after(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); } 8389 { after(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_1()); }
7516) 8390)
7517; 8391;
7518finally { 8392finally {
7519 restoreStackSize(stackSize); 8393 restoreStackSize(stackSize);
7520} 8394}
7521 8395
7522 8396rule__ClassDeclaration__Group_3__2
7523rule__ClassDefinition__Group_3__0
7524 @init { 8397 @init {
7525 int stackSize = keepStackSize(); 8398 int stackSize = keepStackSize();
7526 } 8399 }
7527: 8400:
7528 rule__ClassDefinition__Group_3__0__Impl 8401 rule__ClassDeclaration__Group_3__2__Impl
7529 rule__ClassDefinition__Group_3__1
7530; 8402;
7531finally { 8403finally {
7532 restoreStackSize(stackSize); 8404 restoreStackSize(stackSize);
7533} 8405}
7534 8406
7535rule__ClassDefinition__Group_3__0__Impl 8407rule__ClassDeclaration__Group_3__2__Impl
7536 @init { 8408 @init {
7537 int stackSize = keepStackSize(); 8409 int stackSize = keepStackSize();
7538 } 8410 }
7539: 8411:
7540( 8412(
7541 { before(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); } 8413 { before(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); }
7542 Extends 8414 (rule__ClassDeclaration__Group_3_2__0)*
7543 { after(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); } 8415 { after(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); }
7544) 8416)
7545; 8417;
7546finally { 8418finally {
7547 restoreStackSize(stackSize); 8419 restoreStackSize(stackSize);
7548} 8420}
7549 8421
7550rule__ClassDefinition__Group_3__1 8422
8423rule__ClassDeclaration__Group_3_2__0
7551 @init { 8424 @init {
7552 int stackSize = keepStackSize(); 8425 int stackSize = keepStackSize();
7553 } 8426 }
7554: 8427:
7555 rule__ClassDefinition__Group_3__1__Impl 8428 rule__ClassDeclaration__Group_3_2__0__Impl
7556 rule__ClassDefinition__Group_3__2 8429 rule__ClassDeclaration__Group_3_2__1
7557; 8430;
7558finally { 8431finally {
7559 restoreStackSize(stackSize); 8432 restoreStackSize(stackSize);
7560} 8433}
7561 8434
7562rule__ClassDefinition__Group_3__1__Impl 8435rule__ClassDeclaration__Group_3_2__0__Impl
7563 @init { 8436 @init {
7564 int stackSize = keepStackSize(); 8437 int stackSize = keepStackSize();
7565 } 8438 }
7566: 8439:
7567( 8440(
7568 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); } 8441 { before(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); }
7569 (rule__ClassDefinition__SuperclassesAssignment_3_1) 8442 Comma
7570 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); } 8443 { after(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); }
7571) 8444)
7572; 8445;
7573finally { 8446finally {
7574 restoreStackSize(stackSize); 8447 restoreStackSize(stackSize);
7575} 8448}
7576 8449
7577rule__ClassDefinition__Group_3__2 8450rule__ClassDeclaration__Group_3_2__1
7578 @init { 8451 @init {
7579 int stackSize = keepStackSize(); 8452 int stackSize = keepStackSize();
7580 } 8453 }
7581: 8454:
7582 rule__ClassDefinition__Group_3__2__Impl 8455 rule__ClassDeclaration__Group_3_2__1__Impl
7583; 8456;
7584finally { 8457finally {
7585 restoreStackSize(stackSize); 8458 restoreStackSize(stackSize);
7586} 8459}
7587 8460
7588rule__ClassDefinition__Group_3__2__Impl 8461rule__ClassDeclaration__Group_3_2__1__Impl
7589 @init { 8462 @init {
7590 int stackSize = keepStackSize(); 8463 int stackSize = keepStackSize();
7591 } 8464 }
7592: 8465:
7593( 8466(
7594 { before(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); } 8467 { before(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_2_1()); }
7595 (rule__ClassDefinition__Group_3_2__0)* 8468 (rule__ClassDeclaration__SupertypesAssignment_3_2_1)
7596 { after(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); } 8469 { after(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_2_1()); }
7597) 8470)
7598; 8471;
7599finally { 8472finally {
@@ -7601,53 +8474,80 @@ finally {
7601} 8474}
7602 8475
7603 8476
7604rule__ClassDefinition__Group_3_2__0 8477rule__ClassDeclaration__Group_4_0__0
7605 @init { 8478 @init {
7606 int stackSize = keepStackSize(); 8479 int stackSize = keepStackSize();
7607 } 8480 }
7608: 8481:
7609 rule__ClassDefinition__Group_3_2__0__Impl 8482 rule__ClassDeclaration__Group_4_0__0__Impl
7610 rule__ClassDefinition__Group_3_2__1 8483 rule__ClassDeclaration__Group_4_0__1
7611; 8484;
7612finally { 8485finally {
7613 restoreStackSize(stackSize); 8486 restoreStackSize(stackSize);
7614} 8487}
7615 8488
7616rule__ClassDefinition__Group_3_2__0__Impl 8489rule__ClassDeclaration__Group_4_0__0__Impl
7617 @init { 8490 @init {
7618 int stackSize = keepStackSize(); 8491 int stackSize = keepStackSize();
7619 } 8492 }
7620: 8493:
7621( 8494(
7622 { before(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); } 8495 { before(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); }
7623 Comma 8496 LeftCurlyBracket
7624 { after(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); } 8497 { after(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); }
8498)
8499;
8500finally {
8501 restoreStackSize(stackSize);
8502}
8503
8504rule__ClassDeclaration__Group_4_0__1
8505 @init {
8506 int stackSize = keepStackSize();
8507 }
8508:
8509 rule__ClassDeclaration__Group_4_0__1__Impl
8510 rule__ClassDeclaration__Group_4_0__2
8511;
8512finally {
8513 restoreStackSize(stackSize);
8514}
8515
8516rule__ClassDeclaration__Group_4_0__1__Impl
8517 @init {
8518 int stackSize = keepStackSize();
8519 }
8520:
8521(
8522 { before(grammarAccess.getClassDeclarationAccess().getFieldsAssignment_4_0_1()); }
8523 (rule__ClassDeclaration__FieldsAssignment_4_0_1)*
8524 { after(grammarAccess.getClassDeclarationAccess().getFieldsAssignment_4_0_1()); }
7625) 8525)
7626; 8526;
7627finally { 8527finally {
7628 restoreStackSize(stackSize); 8528 restoreStackSize(stackSize);
7629} 8529}
7630 8530
7631rule__ClassDefinition__Group_3_2__1 8531rule__ClassDeclaration__Group_4_0__2
7632 @init { 8532 @init {
7633 int stackSize = keepStackSize(); 8533 int stackSize = keepStackSize();
7634 } 8534 }
7635: 8535:
7636 rule__ClassDefinition__Group_3_2__1__Impl 8536 rule__ClassDeclaration__Group_4_0__2__Impl
7637; 8537;
7638finally { 8538finally {
7639 restoreStackSize(stackSize); 8539 restoreStackSize(stackSize);
7640} 8540}
7641 8541
7642rule__ClassDefinition__Group_3_2__1__Impl 8542rule__ClassDeclaration__Group_4_0__2__Impl
7643 @init { 8543 @init {
7644 int stackSize = keepStackSize(); 8544 int stackSize = keepStackSize();
7645 } 8545 }
7646: 8546:
7647( 8547(
7648 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); } 8548 { before(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); }
7649 (rule__ClassDefinition__SuperclassesAssignment_3_2_1) 8549 RightCurlyBracket
7650 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); } 8550 { after(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); }
7651) 8551)
7652; 8552;
7653finally { 8553finally {
@@ -7655,161 +8555,161 @@ finally {
7655} 8555}
7656 8556
7657 8557
7658rule__MemberDefinition__Group__0 8558rule__Field__Group__0
7659 @init { 8559 @init {
7660 int stackSize = keepStackSize(); 8560 int stackSize = keepStackSize();
7661 } 8561 }
7662: 8562:
7663 rule__MemberDefinition__Group__0__Impl 8563 rule__Field__Group__0__Impl
7664 rule__MemberDefinition__Group__1 8564 rule__Field__Group__1
7665; 8565;
7666finally { 8566finally {
7667 restoreStackSize(stackSize); 8567 restoreStackSize(stackSize);
7668} 8568}
7669 8569
7670rule__MemberDefinition__Group__0__Impl 8570rule__Field__Group__0__Impl
7671 @init { 8571 @init {
7672 int stackSize = keepStackSize(); 8572 int stackSize = keepStackSize();
7673 } 8573 }
7674: 8574:
7675( 8575(
7676 { before(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); } 8576 { before(grammarAccess.getFieldAccess().getAlternatives_0()); }
7677 (rule__MemberDefinition__ContainmentAssignment_0)? 8577 (rule__Field__Alternatives_0)?
7678 { after(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); } 8578 { after(grammarAccess.getFieldAccess().getAlternatives_0()); }
7679) 8579)
7680; 8580;
7681finally { 8581finally {
7682 restoreStackSize(stackSize); 8582 restoreStackSize(stackSize);
7683} 8583}
7684 8584
7685rule__MemberDefinition__Group__1 8585rule__Field__Group__1
7686 @init { 8586 @init {
7687 int stackSize = keepStackSize(); 8587 int stackSize = keepStackSize();
7688 } 8588 }
7689: 8589:
7690 rule__MemberDefinition__Group__1__Impl 8590 rule__Field__Group__1__Impl
7691 rule__MemberDefinition__Group__2 8591 rule__Field__Group__2
7692; 8592;
7693finally { 8593finally {
7694 restoreStackSize(stackSize); 8594 restoreStackSize(stackSize);
7695} 8595}
7696 8596
7697rule__MemberDefinition__Group__1__Impl 8597rule__Field__Group__1__Impl
7698 @init { 8598 @init {
7699 int stackSize = keepStackSize(); 8599 int stackSize = keepStackSize();
7700 } 8600 }
7701: 8601:
7702( 8602(
7703 { before(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); } 8603 { before(grammarAccess.getFieldAccess().getTypeAssignment_1()); }
7704 (rule__MemberDefinition__TypeAssignment_1) 8604 (rule__Field__TypeAssignment_1)
7705 { after(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); } 8605 { after(grammarAccess.getFieldAccess().getTypeAssignment_1()); }
7706) 8606)
7707; 8607;
7708finally { 8608finally {
7709 restoreStackSize(stackSize); 8609 restoreStackSize(stackSize);
7710} 8610}
7711 8611
7712rule__MemberDefinition__Group__2 8612rule__Field__Group__2
7713 @init { 8613 @init {
7714 int stackSize = keepStackSize(); 8614 int stackSize = keepStackSize();
7715 } 8615 }
7716: 8616:
7717 rule__MemberDefinition__Group__2__Impl 8617 rule__Field__Group__2__Impl
7718 rule__MemberDefinition__Group__3 8618 rule__Field__Group__3
7719; 8619;
7720finally { 8620finally {
7721 restoreStackSize(stackSize); 8621 restoreStackSize(stackSize);
7722} 8622}
7723 8623
7724rule__MemberDefinition__Group__2__Impl 8624rule__Field__Group__2__Impl
7725 @init { 8625 @init {
7726 int stackSize = keepStackSize(); 8626 int stackSize = keepStackSize();
7727 } 8627 }
7728: 8628:
7729( 8629(
7730 { before(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); } 8630 { before(grammarAccess.getFieldAccess().getMultiplicityAssignment_2()); }
7731 (rule__MemberDefinition__MultiplicityAssignment_2)? 8631 (rule__Field__MultiplicityAssignment_2)?
7732 { after(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); } 8632 { after(grammarAccess.getFieldAccess().getMultiplicityAssignment_2()); }
7733) 8633)
7734; 8634;
7735finally { 8635finally {
7736 restoreStackSize(stackSize); 8636 restoreStackSize(stackSize);
7737} 8637}
7738 8638
7739rule__MemberDefinition__Group__3 8639rule__Field__Group__3
7740 @init { 8640 @init {
7741 int stackSize = keepStackSize(); 8641 int stackSize = keepStackSize();
7742 } 8642 }
7743: 8643:
7744 rule__MemberDefinition__Group__3__Impl 8644 rule__Field__Group__3__Impl
7745 rule__MemberDefinition__Group__4 8645 rule__Field__Group__4
7746; 8646;
7747finally { 8647finally {
7748 restoreStackSize(stackSize); 8648 restoreStackSize(stackSize);
7749} 8649}
7750 8650
7751rule__MemberDefinition__Group__3__Impl 8651rule__Field__Group__3__Impl
7752 @init { 8652 @init {
7753 int stackSize = keepStackSize(); 8653 int stackSize = keepStackSize();
7754 } 8654 }
7755: 8655:
7756( 8656(
7757 { before(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); } 8657 { before(grammarAccess.getFieldAccess().getNameAssignment_3()); }
7758 (rule__MemberDefinition__NameAssignment_3) 8658 (rule__Field__NameAssignment_3)
7759 { after(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); } 8659 { after(grammarAccess.getFieldAccess().getNameAssignment_3()); }
7760) 8660)
7761; 8661;
7762finally { 8662finally {
7763 restoreStackSize(stackSize); 8663 restoreStackSize(stackSize);
7764} 8664}
7765 8665
7766rule__MemberDefinition__Group__4 8666rule__Field__Group__4
7767 @init { 8667 @init {
7768 int stackSize = keepStackSize(); 8668 int stackSize = keepStackSize();
7769 } 8669 }
7770: 8670:
7771 rule__MemberDefinition__Group__4__Impl 8671 rule__Field__Group__4__Impl
7772 rule__MemberDefinition__Group__5 8672 rule__Field__Group__5
7773; 8673;
7774finally { 8674finally {
7775 restoreStackSize(stackSize); 8675 restoreStackSize(stackSize);
7776} 8676}
7777 8677
7778rule__MemberDefinition__Group__4__Impl 8678rule__Field__Group__4__Impl
7779 @init { 8679 @init {
7780 int stackSize = keepStackSize(); 8680 int stackSize = keepStackSize();
7781 } 8681 }
7782: 8682:
7783( 8683(
7784 { before(grammarAccess.getMemberDefinitionAccess().getGroup_4()); } 8684 { before(grammarAccess.getFieldAccess().getGroup_4()); }
7785 (rule__MemberDefinition__Group_4__0)? 8685 (rule__Field__Group_4__0)?
7786 { after(grammarAccess.getMemberDefinitionAccess().getGroup_4()); } 8686 { after(grammarAccess.getFieldAccess().getGroup_4()); }
7787) 8687)
7788; 8688;
7789finally { 8689finally {
7790 restoreStackSize(stackSize); 8690 restoreStackSize(stackSize);
7791} 8691}
7792 8692
7793rule__MemberDefinition__Group__5 8693rule__Field__Group__5
7794 @init { 8694 @init {
7795 int stackSize = keepStackSize(); 8695 int stackSize = keepStackSize();
7796 } 8696 }
7797: 8697:
7798 rule__MemberDefinition__Group__5__Impl 8698 rule__Field__Group__5__Impl
7799; 8699;
7800finally { 8700finally {
7801 restoreStackSize(stackSize); 8701 restoreStackSize(stackSize);
7802} 8702}
7803 8703
7804rule__MemberDefinition__Group__5__Impl 8704rule__Field__Group__5__Impl
7805 @init { 8705 @init {
7806 int stackSize = keepStackSize(); 8706 int stackSize = keepStackSize();
7807 } 8707 }
7808: 8708:
7809( 8709(
7810 { before(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); } 8710 { before(grammarAccess.getFieldAccess().getSemicolonKeyword_5()); }
7811 (Semicolon)? 8711 (Semicolon)?
7812 { after(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); } 8712 { after(grammarAccess.getFieldAccess().getSemicolonKeyword_5()); }
7813) 8713)
7814; 8714;
7815finally { 8715finally {
@@ -7817,53 +8717,53 @@ finally {
7817} 8717}
7818 8718
7819 8719
7820rule__MemberDefinition__Group_4__0 8720rule__Field__Group_4__0
7821 @init { 8721 @init {
7822 int stackSize = keepStackSize(); 8722 int stackSize = keepStackSize();
7823 } 8723 }
7824: 8724:
7825 rule__MemberDefinition__Group_4__0__Impl 8725 rule__Field__Group_4__0__Impl
7826 rule__MemberDefinition__Group_4__1 8726 rule__Field__Group_4__1
7827; 8727;
7828finally { 8728finally {
7829 restoreStackSize(stackSize); 8729 restoreStackSize(stackSize);
7830} 8730}
7831 8731
7832rule__MemberDefinition__Group_4__0__Impl 8732rule__Field__Group_4__0__Impl
7833 @init { 8733 @init {
7834 int stackSize = keepStackSize(); 8734 int stackSize = keepStackSize();
7835 } 8735 }
7836: 8736:
7837( 8737(
7838 { before(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); } 8738 { before(grammarAccess.getFieldAccess().getOppositeKeyword_4_0()); }
7839 Opposite 8739 Opposite
7840 { after(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); } 8740 { after(grammarAccess.getFieldAccess().getOppositeKeyword_4_0()); }
7841) 8741)
7842; 8742;
7843finally { 8743finally {
7844 restoreStackSize(stackSize); 8744 restoreStackSize(stackSize);
7845} 8745}
7846 8746
7847rule__MemberDefinition__Group_4__1 8747rule__Field__Group_4__1
7848 @init { 8748 @init {
7849 int stackSize = keepStackSize(); 8749 int stackSize = keepStackSize();
7850 } 8750 }
7851: 8751:
7852 rule__MemberDefinition__Group_4__1__Impl 8752 rule__Field__Group_4__1__Impl
7853; 8753;
7854finally { 8754finally {
7855 restoreStackSize(stackSize); 8755 restoreStackSize(stackSize);
7856} 8756}
7857 8757
7858rule__MemberDefinition__Group_4__1__Impl 8758rule__Field__Group_4__1__Impl
7859 @init { 8759 @init {
7860 int stackSize = keepStackSize(); 8760 int stackSize = keepStackSize();
7861 } 8761 }
7862: 8762:
7863( 8763(
7864 { before(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); } 8764 { before(grammarAccess.getFieldAccess().getOppositeAssignment_4_1()); }
7865 (rule__MemberDefinition__OppositeAssignment_4_1) 8765 (rule__Field__OppositeAssignment_4_1)
7866 { after(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); } 8766 { after(grammarAccess.getFieldAccess().getOppositeAssignment_4_1()); }
7867) 8767)
7868; 8768;
7869finally { 8769finally {
@@ -7871,80 +8771,80 @@ finally {
7871} 8771}
7872 8772
7873 8773
7874rule__ManyMultiplicity__Group__0 8774rule__UnboundedMultiplicity__Group__0
7875 @init { 8775 @init {
7876 int stackSize = keepStackSize(); 8776 int stackSize = keepStackSize();
7877 } 8777 }
7878: 8778:
7879 rule__ManyMultiplicity__Group__0__Impl 8779 rule__UnboundedMultiplicity__Group__0__Impl
7880 rule__ManyMultiplicity__Group__1 8780 rule__UnboundedMultiplicity__Group__1
7881; 8781;
7882finally { 8782finally {
7883 restoreStackSize(stackSize); 8783 restoreStackSize(stackSize);
7884} 8784}
7885 8785
7886rule__ManyMultiplicity__Group__0__Impl 8786rule__UnboundedMultiplicity__Group__0__Impl
7887 @init { 8787 @init {
7888 int stackSize = keepStackSize(); 8788 int stackSize = keepStackSize();
7889 } 8789 }
7890: 8790:
7891( 8791(
7892 { before(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); } 8792 { before(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction_0()); }
7893 () 8793 ()
7894 { after(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); } 8794 { after(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction_0()); }
7895) 8795)
7896; 8796;
7897finally { 8797finally {
7898 restoreStackSize(stackSize); 8798 restoreStackSize(stackSize);
7899} 8799}
7900 8800
7901rule__ManyMultiplicity__Group__1 8801rule__UnboundedMultiplicity__Group__1
7902 @init { 8802 @init {
7903 int stackSize = keepStackSize(); 8803 int stackSize = keepStackSize();
7904 } 8804 }
7905: 8805:
7906 rule__ManyMultiplicity__Group__1__Impl 8806 rule__UnboundedMultiplicity__Group__1__Impl
7907 rule__ManyMultiplicity__Group__2 8807 rule__UnboundedMultiplicity__Group__2
7908; 8808;
7909finally { 8809finally {
7910 restoreStackSize(stackSize); 8810 restoreStackSize(stackSize);
7911} 8811}
7912 8812
7913rule__ManyMultiplicity__Group__1__Impl 8813rule__UnboundedMultiplicity__Group__1__Impl
7914 @init { 8814 @init {
7915 int stackSize = keepStackSize(); 8815 int stackSize = keepStackSize();
7916 } 8816 }
7917: 8817:
7918( 8818(
7919 { before(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); } 8819 { before(grammarAccess.getUnboundedMultiplicityAccess().getLeftSquareBracketKeyword_1()); }
7920 LeftSquareBracket 8820 LeftSquareBracket
7921 { after(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); } 8821 { after(grammarAccess.getUnboundedMultiplicityAccess().getLeftSquareBracketKeyword_1()); }
7922) 8822)
7923; 8823;
7924finally { 8824finally {
7925 restoreStackSize(stackSize); 8825 restoreStackSize(stackSize);
7926} 8826}
7927 8827
7928rule__ManyMultiplicity__Group__2 8828rule__UnboundedMultiplicity__Group__2
7929 @init { 8829 @init {
7930 int stackSize = keepStackSize(); 8830 int stackSize = keepStackSize();
7931 } 8831 }
7932: 8832:
7933 rule__ManyMultiplicity__Group__2__Impl 8833 rule__UnboundedMultiplicity__Group__2__Impl
7934; 8834;
7935finally { 8835finally {
7936 restoreStackSize(stackSize); 8836 restoreStackSize(stackSize);
7937} 8837}
7938 8838
7939rule__ManyMultiplicity__Group__2__Impl 8839rule__UnboundedMultiplicity__Group__2__Impl
7940 @init { 8840 @init {
7941 int stackSize = keepStackSize(); 8841 int stackSize = keepStackSize();
7942 } 8842 }
7943: 8843:
7944( 8844(
7945 { before(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); } 8845 { before(grammarAccess.getUnboundedMultiplicityAccess().getRightSquareBracketKeyword_2()); }
7946 RightSquareBracket 8846 RightSquareBracket
7947 { after(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); } 8847 { after(grammarAccess.getUnboundedMultiplicityAccess().getRightSquareBracketKeyword_2()); }
7948) 8848)
7949; 8849;
7950finally { 8850finally {
@@ -7997,9 +8897,9 @@ rule__ExactMultiplicity__Group__1__Impl
7997 } 8897 }
7998: 8898:
7999( 8899(
8000 { before(grammarAccess.getExactMultiplicityAccess().getMultiplicityAssignment_1()); } 8900 { before(grammarAccess.getExactMultiplicityAccess().getValueAssignment_1()); }
8001 (rule__ExactMultiplicity__MultiplicityAssignment_1) 8901 (rule__ExactMultiplicity__ValueAssignment_1)
8002 { after(grammarAccess.getExactMultiplicityAccess().getMultiplicityAssignment_1()); } 8902 { after(grammarAccess.getExactMultiplicityAccess().getValueAssignment_1()); }
8003) 8903)
8004; 8904;
8005finally { 8905finally {
@@ -8105,9 +9005,9 @@ rule__BoundedMultiplicity__Group__2__Impl
8105 } 9005 }
8106: 9006:
8107( 9007(
8108 { before(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); } 9008 { before(grammarAccess.getBoundedMultiplicityAccess().getCommaKeyword_2()); }
8109 FullStopFullStop 9009 Comma
8110 { after(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); } 9010 { after(grammarAccess.getBoundedMultiplicityAccess().getCommaKeyword_2()); }
8111) 9011)
8112; 9012;
8113finally { 9013finally {
@@ -8168,107 +9068,404 @@ finally {
8168} 9068}
8169 9069
8170 9070
8171rule__ExactScopeDefinition__Group__0 9071rule__EnumDeclaration__Group__0
8172 @init { 9072 @init {
8173 int stackSize = keepStackSize(); 9073 int stackSize = keepStackSize();
8174 } 9074 }
8175: 9075:
8176 rule__ExactScopeDefinition__Group__0__Impl 9076 rule__EnumDeclaration__Group__0__Impl
8177 rule__ExactScopeDefinition__Group__1 9077 rule__EnumDeclaration__Group__1
8178; 9078;
8179finally { 9079finally {
8180 restoreStackSize(stackSize); 9080 restoreStackSize(stackSize);
8181} 9081}
8182 9082
8183rule__ExactScopeDefinition__Group__0__Impl 9083rule__EnumDeclaration__Group__0__Impl
8184 @init { 9084 @init {
8185 int stackSize = keepStackSize(); 9085 int stackSize = keepStackSize();
8186 } 9086 }
8187: 9087:
8188( 9088(
8189 { before(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); } 9089 { before(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); }
9090 Enum
9091 { after(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); }
9092)
9093;
9094finally {
9095 restoreStackSize(stackSize);
9096}
9097
9098rule__EnumDeclaration__Group__1
9099 @init {
9100 int stackSize = keepStackSize();
9101 }
9102:
9103 rule__EnumDeclaration__Group__1__Impl
9104 rule__EnumDeclaration__Group__2
9105;
9106finally {
9107 restoreStackSize(stackSize);
9108}
9109
9110rule__EnumDeclaration__Group__1__Impl
9111 @init {
9112 int stackSize = keepStackSize();
9113 }
9114:
9115(
9116 { before(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); }
9117 (rule__EnumDeclaration__NameAssignment_1)
9118 { after(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); }
9119)
9120;
9121finally {
9122 restoreStackSize(stackSize);
9123}
9124
9125rule__EnumDeclaration__Group__2
9126 @init {
9127 int stackSize = keepStackSize();
9128 }
9129:
9130 rule__EnumDeclaration__Group__2__Impl
9131;
9132finally {
9133 restoreStackSize(stackSize);
9134}
9135
9136rule__EnumDeclaration__Group__2__Impl
9137 @init {
9138 int stackSize = keepStackSize();
9139 }
9140:
9141(
9142 { before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); }
9143 (rule__EnumDeclaration__Alternatives_2)
9144 { after(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); }
9145)
9146;
9147finally {
9148 restoreStackSize(stackSize);
9149}
9150
9151
9152rule__EnumDeclaration__Group_2_0__0
9153 @init {
9154 int stackSize = keepStackSize();
9155 }
9156:
9157 rule__EnumDeclaration__Group_2_0__0__Impl
9158 rule__EnumDeclaration__Group_2_0__1
9159;
9160finally {
9161 restoreStackSize(stackSize);
9162}
9163
9164rule__EnumDeclaration__Group_2_0__0__Impl
9165 @init {
9166 int stackSize = keepStackSize();
9167 }
9168:
9169(
9170 { before(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); }
9171 LeftCurlyBracket
9172 { after(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); }
9173)
9174;
9175finally {
9176 restoreStackSize(stackSize);
9177}
9178
9179rule__EnumDeclaration__Group_2_0__1
9180 @init {
9181 int stackSize = keepStackSize();
9182 }
9183:
9184 rule__EnumDeclaration__Group_2_0__1__Impl
9185 rule__EnumDeclaration__Group_2_0__2
9186;
9187finally {
9188 restoreStackSize(stackSize);
9189}
9190
9191rule__EnumDeclaration__Group_2_0__1__Impl
9192 @init {
9193 int stackSize = keepStackSize();
9194 }
9195:
9196(
9197 { before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); }
9198 (rule__EnumDeclaration__Group_2_0_1__0)?
9199 { after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); }
9200)
9201;
9202finally {
9203 restoreStackSize(stackSize);
9204}
9205
9206rule__EnumDeclaration__Group_2_0__2
9207 @init {
9208 int stackSize = keepStackSize();
9209 }
9210:
9211 rule__EnumDeclaration__Group_2_0__2__Impl
9212;
9213finally {
9214 restoreStackSize(stackSize);
9215}
9216
9217rule__EnumDeclaration__Group_2_0__2__Impl
9218 @init {
9219 int stackSize = keepStackSize();
9220 }
9221:
9222(
9223 { before(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); }
9224 RightCurlyBracket
9225 { after(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); }
9226)
9227;
9228finally {
9229 restoreStackSize(stackSize);
9230}
9231
9232
9233rule__EnumDeclaration__Group_2_0_1__0
9234 @init {
9235 int stackSize = keepStackSize();
9236 }
9237:
9238 rule__EnumDeclaration__Group_2_0_1__0__Impl
9239 rule__EnumDeclaration__Group_2_0_1__1
9240;
9241finally {
9242 restoreStackSize(stackSize);
9243}
9244
9245rule__EnumDeclaration__Group_2_0_1__0__Impl
9246 @init {
9247 int stackSize = keepStackSize();
9248 }
9249:
9250(
9251 { before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); }
9252 (rule__EnumDeclaration__LiteralsAssignment_2_0_1_0)
9253 { after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); }
9254)
9255;
9256finally {
9257 restoreStackSize(stackSize);
9258}
9259
9260rule__EnumDeclaration__Group_2_0_1__1
9261 @init {
9262 int stackSize = keepStackSize();
9263 }
9264:
9265 rule__EnumDeclaration__Group_2_0_1__1__Impl
9266;
9267finally {
9268 restoreStackSize(stackSize);
9269}
9270
9271rule__EnumDeclaration__Group_2_0_1__1__Impl
9272 @init {
9273 int stackSize = keepStackSize();
9274 }
9275:
9276(
9277 { before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); }
9278 (rule__EnumDeclaration__Group_2_0_1_1__0)*
9279 { after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); }
9280)
9281;
9282finally {
9283 restoreStackSize(stackSize);
9284}
9285
9286
9287rule__EnumDeclaration__Group_2_0_1_1__0
9288 @init {
9289 int stackSize = keepStackSize();
9290 }
9291:
9292 rule__EnumDeclaration__Group_2_0_1_1__0__Impl
9293 rule__EnumDeclaration__Group_2_0_1_1__1
9294;
9295finally {
9296 restoreStackSize(stackSize);
9297}
9298
9299rule__EnumDeclaration__Group_2_0_1_1__0__Impl
9300 @init {
9301 int stackSize = keepStackSize();
9302 }
9303:
9304(
9305 { before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); }
9306 (Comma)?
9307 { after(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); }
9308)
9309;
9310finally {
9311 restoreStackSize(stackSize);
9312}
9313
9314rule__EnumDeclaration__Group_2_0_1_1__1
9315 @init {
9316 int stackSize = keepStackSize();
9317 }
9318:
9319 rule__EnumDeclaration__Group_2_0_1_1__1__Impl
9320;
9321finally {
9322 restoreStackSize(stackSize);
9323}
9324
9325rule__EnumDeclaration__Group_2_0_1_1__1__Impl
9326 @init {
9327 int stackSize = keepStackSize();
9328 }
9329:
9330(
9331 { before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); }
9332 (rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1)
9333 { after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); }
9334)
9335;
9336finally {
9337 restoreStackSize(stackSize);
9338}
9339
9340
9341rule__ExactScope__Group__0
9342 @init {
9343 int stackSize = keepStackSize();
9344 }
9345:
9346 rule__ExactScope__Group__0__Impl
9347 rule__ExactScope__Group__1
9348;
9349finally {
9350 restoreStackSize(stackSize);
9351}
9352
9353rule__ExactScope__Group__0__Impl
9354 @init {
9355 int stackSize = keepStackSize();
9356 }
9357:
9358(
9359 { before(grammarAccess.getExactScopeAccess().getScopeKeyword_0()); }
8190 Scope 9360 Scope
8191 { after(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); } 9361 { after(grammarAccess.getExactScopeAccess().getScopeKeyword_0()); }
8192) 9362)
8193; 9363;
8194finally { 9364finally {
8195 restoreStackSize(stackSize); 9365 restoreStackSize(stackSize);
8196} 9366}
8197 9367
8198rule__ExactScopeDefinition__Group__1 9368rule__ExactScope__Group__1
8199 @init { 9369 @init {
8200 int stackSize = keepStackSize(); 9370 int stackSize = keepStackSize();
8201 } 9371 }
8202: 9372:
8203 rule__ExactScopeDefinition__Group__1__Impl 9373 rule__ExactScope__Group__1__Impl
8204 rule__ExactScopeDefinition__Group__2 9374 rule__ExactScope__Group__2
8205; 9375;
8206finally { 9376finally {
8207 restoreStackSize(stackSize); 9377 restoreStackSize(stackSize);
8208} 9378}
8209 9379
8210rule__ExactScopeDefinition__Group__1__Impl 9380rule__ExactScope__Group__1__Impl
8211 @init { 9381 @init {
8212 int stackSize = keepStackSize(); 9382 int stackSize = keepStackSize();
8213 } 9383 }
8214: 9384:
8215( 9385(
8216 { before(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); } 9386 { before(grammarAccess.getExactScopeAccess().getTypeAssignment_1()); }
8217 (rule__ExactScopeDefinition__TypeAssignment_1) 9387 (rule__ExactScope__TypeAssignment_1)
8218 { after(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); } 9388 { after(grammarAccess.getExactScopeAccess().getTypeAssignment_1()); }
8219) 9389)
8220; 9390;
8221finally { 9391finally {
8222 restoreStackSize(stackSize); 9392 restoreStackSize(stackSize);
8223} 9393}
8224 9394
8225rule__ExactScopeDefinition__Group__2 9395rule__ExactScope__Group__2
8226 @init { 9396 @init {
8227 int stackSize = keepStackSize(); 9397 int stackSize = keepStackSize();
8228 } 9398 }
8229: 9399:
8230 rule__ExactScopeDefinition__Group__2__Impl 9400 rule__ExactScope__Group__2__Impl
8231 rule__ExactScopeDefinition__Group__3 9401 rule__ExactScope__Group__3
8232; 9402;
8233finally { 9403finally {
8234 restoreStackSize(stackSize); 9404 restoreStackSize(stackSize);
8235} 9405}
8236 9406
8237rule__ExactScopeDefinition__Group__2__Impl 9407rule__ExactScope__Group__2__Impl
8238 @init { 9408 @init {
8239 int stackSize = keepStackSize(); 9409 int stackSize = keepStackSize();
8240 } 9410 }
8241: 9411:
8242( 9412(
8243 { before(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); } 9413 { before(grammarAccess.getExactScopeAccess().getEqualsSignEqualsSignKeyword_2()); }
8244 EqualsSignEqualsSign 9414 EqualsSignEqualsSign
8245 { after(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); } 9415 { after(grammarAccess.getExactScopeAccess().getEqualsSignEqualsSignKeyword_2()); }
9416)
9417;
9418finally {
9419 restoreStackSize(stackSize);
9420}
9421
9422rule__ExactScope__Group__3
9423 @init {
9424 int stackSize = keepStackSize();
9425 }
9426:
9427 rule__ExactScope__Group__3__Impl
9428 rule__ExactScope__Group__4
9429;
9430finally {
9431 restoreStackSize(stackSize);
9432}
9433
9434rule__ExactScope__Group__3__Impl
9435 @init {
9436 int stackSize = keepStackSize();
9437 }
9438:
9439(
9440 { before(grammarAccess.getExactScopeAccess().getSizeAssignment_3()); }
9441 (rule__ExactScope__SizeAssignment_3)
9442 { after(grammarAccess.getExactScopeAccess().getSizeAssignment_3()); }
8246) 9443)
8247; 9444;
8248finally { 9445finally {
8249 restoreStackSize(stackSize); 9446 restoreStackSize(stackSize);
8250} 9447}
8251 9448
8252rule__ExactScopeDefinition__Group__3 9449rule__ExactScope__Group__4
8253 @init { 9450 @init {
8254 int stackSize = keepStackSize(); 9451 int stackSize = keepStackSize();
8255 } 9452 }
8256: 9453:
8257 rule__ExactScopeDefinition__Group__3__Impl 9454 rule__ExactScope__Group__4__Impl
8258; 9455;
8259finally { 9456finally {
8260 restoreStackSize(stackSize); 9457 restoreStackSize(stackSize);
8261} 9458}
8262 9459
8263rule__ExactScopeDefinition__Group__3__Impl 9460rule__ExactScope__Group__4__Impl
8264 @init { 9461 @init {
8265 int stackSize = keepStackSize(); 9462 int stackSize = keepStackSize();
8266 } 9463 }
8267: 9464:
8268( 9465(
8269 { before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); } 9466 { before(grammarAccess.getExactScopeAccess().getFULL_STOPTerminalRuleCall_4()); }
8270 (rule__ExactScopeDefinition__ExactScopeAssignment_3) 9467 RULE_FULL_STOP
8271 { after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); } 9468 { after(grammarAccess.getExactScopeAccess().getFULL_STOPTerminalRuleCall_4()); }
8272) 9469)
8273; 9470;
8274finally { 9471finally {
@@ -8276,53 +9473,80 @@ finally {
8276} 9473}
8277 9474
8278 9475
8279rule__BoundedScopeDefinition__Group__0 9476rule__BoundedScope__Group__0
8280 @init { 9477 @init {
8281 int stackSize = keepStackSize(); 9478 int stackSize = keepStackSize();
8282 } 9479 }
8283: 9480:
8284 rule__BoundedScopeDefinition__Group__0__Impl 9481 rule__BoundedScope__Group__0__Impl
8285 rule__BoundedScopeDefinition__Group__1 9482 rule__BoundedScope__Group__1
8286; 9483;
8287finally { 9484finally {
8288 restoreStackSize(stackSize); 9485 restoreStackSize(stackSize);
8289} 9486}
8290 9487
8291rule__BoundedScopeDefinition__Group__0__Impl 9488rule__BoundedScope__Group__0__Impl
8292 @init { 9489 @init {
8293 int stackSize = keepStackSize(); 9490 int stackSize = keepStackSize();
8294 } 9491 }
8295: 9492:
8296( 9493(
8297 { before(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); } 9494 { before(grammarAccess.getBoundedScopeAccess().getScopeKeyword_0()); }
8298 Scope 9495 Scope
8299 { after(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); } 9496 { after(grammarAccess.getBoundedScopeAccess().getScopeKeyword_0()); }
9497)
9498;
9499finally {
9500 restoreStackSize(stackSize);
9501}
9502
9503rule__BoundedScope__Group__1
9504 @init {
9505 int stackSize = keepStackSize();
9506 }
9507:
9508 rule__BoundedScope__Group__1__Impl
9509 rule__BoundedScope__Group__2
9510;
9511finally {
9512 restoreStackSize(stackSize);
9513}
9514
9515rule__BoundedScope__Group__1__Impl
9516 @init {
9517 int stackSize = keepStackSize();
9518 }
9519:
9520(
9521 { before(grammarAccess.getBoundedScopeAccess().getAlternatives_1()); }
9522 (rule__BoundedScope__Alternatives_1)
9523 { after(grammarAccess.getBoundedScopeAccess().getAlternatives_1()); }
8300) 9524)
8301; 9525;
8302finally { 9526finally {
8303 restoreStackSize(stackSize); 9527 restoreStackSize(stackSize);
8304} 9528}
8305 9529
8306rule__BoundedScopeDefinition__Group__1 9530rule__BoundedScope__Group__2
8307 @init { 9531 @init {
8308 int stackSize = keepStackSize(); 9532 int stackSize = keepStackSize();
8309 } 9533 }
8310: 9534:
8311 rule__BoundedScopeDefinition__Group__1__Impl 9535 rule__BoundedScope__Group__2__Impl
8312; 9536;
8313finally { 9537finally {
8314 restoreStackSize(stackSize); 9538 restoreStackSize(stackSize);
8315} 9539}
8316 9540
8317rule__BoundedScopeDefinition__Group__1__Impl 9541rule__BoundedScope__Group__2__Impl
8318 @init { 9542 @init {
8319 int stackSize = keepStackSize(); 9543 int stackSize = keepStackSize();
8320 } 9544 }
8321: 9545:
8322( 9546(
8323 { before(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); } 9547 { before(grammarAccess.getBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); }
8324 (rule__BoundedScopeDefinition__Alternatives_1) 9548 RULE_FULL_STOP
8325 { after(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); } 9549 { after(grammarAccess.getBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); }
8326) 9550)
8327; 9551;
8328finally { 9552finally {
@@ -8330,107 +9554,107 @@ finally {
8330} 9554}
8331 9555
8332 9556
8333rule__BoundedScopeDefinition__Group_1_0__0 9557rule__BoundedScope__Group_1_0__0
8334 @init { 9558 @init {
8335 int stackSize = keepStackSize(); 9559 int stackSize = keepStackSize();
8336 } 9560 }
8337: 9561:
8338 rule__BoundedScopeDefinition__Group_1_0__0__Impl 9562 rule__BoundedScope__Group_1_0__0__Impl
8339 rule__BoundedScopeDefinition__Group_1_0__1 9563 rule__BoundedScope__Group_1_0__1
8340; 9564;
8341finally { 9565finally {
8342 restoreStackSize(stackSize); 9566 restoreStackSize(stackSize);
8343} 9567}
8344 9568
8345rule__BoundedScopeDefinition__Group_1_0__0__Impl 9569rule__BoundedScope__Group_1_0__0__Impl
8346 @init { 9570 @init {
8347 int stackSize = keepStackSize(); 9571 int stackSize = keepStackSize();
8348 } 9572 }
8349: 9573:
8350( 9574(
8351 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); } 9575 { before(grammarAccess.getBoundedScopeAccess().getGroup_1_0_0()); }
8352 (rule__BoundedScopeDefinition__Group_1_0_0__0)? 9576 (rule__BoundedScope__Group_1_0_0__0)?
8353 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); } 9577 { after(grammarAccess.getBoundedScopeAccess().getGroup_1_0_0()); }
8354) 9578)
8355; 9579;
8356finally { 9580finally {
8357 restoreStackSize(stackSize); 9581 restoreStackSize(stackSize);
8358} 9582}
8359 9583
8360rule__BoundedScopeDefinition__Group_1_0__1 9584rule__BoundedScope__Group_1_0__1
8361 @init { 9585 @init {
8362 int stackSize = keepStackSize(); 9586 int stackSize = keepStackSize();
8363 } 9587 }
8364: 9588:
8365 rule__BoundedScopeDefinition__Group_1_0__1__Impl 9589 rule__BoundedScope__Group_1_0__1__Impl
8366 rule__BoundedScopeDefinition__Group_1_0__2 9590 rule__BoundedScope__Group_1_0__2
8367; 9591;
8368finally { 9592finally {
8369 restoreStackSize(stackSize); 9593 restoreStackSize(stackSize);
8370} 9594}
8371 9595
8372rule__BoundedScopeDefinition__Group_1_0__1__Impl 9596rule__BoundedScope__Group_1_0__1__Impl
8373 @init { 9597 @init {
8374 int stackSize = keepStackSize(); 9598 int stackSize = keepStackSize();
8375 } 9599 }
8376: 9600:
8377( 9601(
8378 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); } 9602 { before(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_0_1()); }
8379 (rule__BoundedScopeDefinition__TypeAssignment_1_0_1) 9603 (rule__BoundedScope__TypeAssignment_1_0_1)
8380 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); } 9604 { after(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_0_1()); }
8381) 9605)
8382; 9606;
8383finally { 9607finally {
8384 restoreStackSize(stackSize); 9608 restoreStackSize(stackSize);
8385} 9609}
8386 9610
8387rule__BoundedScopeDefinition__Group_1_0__2 9611rule__BoundedScope__Group_1_0__2
8388 @init { 9612 @init {
8389 int stackSize = keepStackSize(); 9613 int stackSize = keepStackSize();
8390 } 9614 }
8391: 9615:
8392 rule__BoundedScopeDefinition__Group_1_0__2__Impl 9616 rule__BoundedScope__Group_1_0__2__Impl
8393 rule__BoundedScopeDefinition__Group_1_0__3 9617 rule__BoundedScope__Group_1_0__3
8394; 9618;
8395finally { 9619finally {
8396 restoreStackSize(stackSize); 9620 restoreStackSize(stackSize);
8397} 9621}
8398 9622
8399rule__BoundedScopeDefinition__Group_1_0__2__Impl 9623rule__BoundedScope__Group_1_0__2__Impl
8400 @init { 9624 @init {
8401 int stackSize = keepStackSize(); 9625 int stackSize = keepStackSize();
8402 } 9626 }
8403: 9627:
8404( 9628(
8405 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); } 9629 { before(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_2()); }
8406 LessThanSignEqualsSign 9630 LessThanSignEqualsSign
8407 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); } 9631 { after(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_2()); }
8408) 9632)
8409; 9633;
8410finally { 9634finally {
8411 restoreStackSize(stackSize); 9635 restoreStackSize(stackSize);
8412} 9636}
8413 9637
8414rule__BoundedScopeDefinition__Group_1_0__3 9638rule__BoundedScope__Group_1_0__3
8415 @init { 9639 @init {
8416 int stackSize = keepStackSize(); 9640 int stackSize = keepStackSize();
8417 } 9641 }
8418: 9642:
8419 rule__BoundedScopeDefinition__Group_1_0__3__Impl 9643 rule__BoundedScope__Group_1_0__3__Impl
8420; 9644;
8421finally { 9645finally {
8422 restoreStackSize(stackSize); 9646 restoreStackSize(stackSize);
8423} 9647}
8424 9648
8425rule__BoundedScopeDefinition__Group_1_0__3__Impl 9649rule__BoundedScope__Group_1_0__3__Impl
8426 @init { 9650 @init {
8427 int stackSize = keepStackSize(); 9651 int stackSize = keepStackSize();
8428 } 9652 }
8429: 9653:
8430( 9654(
8431 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); } 9655 { before(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_0_3()); }
8432 (rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3) 9656 (rule__BoundedScope__UpperBoundAssignment_1_0_3)
8433 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); } 9657 { after(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_0_3()); }
8434) 9658)
8435; 9659;
8436finally { 9660finally {
@@ -8438,53 +9662,53 @@ finally {
8438} 9662}
8439 9663
8440 9664
8441rule__BoundedScopeDefinition__Group_1_0_0__0 9665rule__BoundedScope__Group_1_0_0__0
8442 @init { 9666 @init {
8443 int stackSize = keepStackSize(); 9667 int stackSize = keepStackSize();
8444 } 9668 }
8445: 9669:
8446 rule__BoundedScopeDefinition__Group_1_0_0__0__Impl 9670 rule__BoundedScope__Group_1_0_0__0__Impl
8447 rule__BoundedScopeDefinition__Group_1_0_0__1 9671 rule__BoundedScope__Group_1_0_0__1
8448; 9672;
8449finally { 9673finally {
8450 restoreStackSize(stackSize); 9674 restoreStackSize(stackSize);
8451} 9675}
8452 9676
8453rule__BoundedScopeDefinition__Group_1_0_0__0__Impl 9677rule__BoundedScope__Group_1_0_0__0__Impl
8454 @init { 9678 @init {
8455 int stackSize = keepStackSize(); 9679 int stackSize = keepStackSize();
8456 } 9680 }
8457: 9681:
8458( 9682(
8459 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); } 9683 { before(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_0_0_0()); }
8460 (rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0) 9684 (rule__BoundedScope__LowerBoundAssignment_1_0_0_0)
8461 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); } 9685 { after(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_0_0_0()); }
8462) 9686)
8463; 9687;
8464finally { 9688finally {
8465 restoreStackSize(stackSize); 9689 restoreStackSize(stackSize);
8466} 9690}
8467 9691
8468rule__BoundedScopeDefinition__Group_1_0_0__1 9692rule__BoundedScope__Group_1_0_0__1
8469 @init { 9693 @init {
8470 int stackSize = keepStackSize(); 9694 int stackSize = keepStackSize();
8471 } 9695 }
8472: 9696:
8473 rule__BoundedScopeDefinition__Group_1_0_0__1__Impl 9697 rule__BoundedScope__Group_1_0_0__1__Impl
8474; 9698;
8475finally { 9699finally {
8476 restoreStackSize(stackSize); 9700 restoreStackSize(stackSize);
8477} 9701}
8478 9702
8479rule__BoundedScopeDefinition__Group_1_0_0__1__Impl 9703rule__BoundedScope__Group_1_0_0__1__Impl
8480 @init { 9704 @init {
8481 int stackSize = keepStackSize(); 9705 int stackSize = keepStackSize();
8482 } 9706 }
8483: 9707:
8484( 9708(
8485 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); } 9709 { before(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); }
8486 LessThanSignEqualsSign 9710 LessThanSignEqualsSign
8487 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); } 9711 { after(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); }
8488) 9712)
8489; 9713;
8490finally { 9714finally {
@@ -8492,107 +9716,107 @@ finally {
8492} 9716}
8493 9717
8494 9718
8495rule__BoundedScopeDefinition__Group_1_1__0 9719rule__BoundedScope__Group_1_1__0
8496 @init { 9720 @init {
8497 int stackSize = keepStackSize(); 9721 int stackSize = keepStackSize();
8498 } 9722 }
8499: 9723:
8500 rule__BoundedScopeDefinition__Group_1_1__0__Impl 9724 rule__BoundedScope__Group_1_1__0__Impl
8501 rule__BoundedScopeDefinition__Group_1_1__1 9725 rule__BoundedScope__Group_1_1__1
8502; 9726;
8503finally { 9727finally {
8504 restoreStackSize(stackSize); 9728 restoreStackSize(stackSize);
8505} 9729}
8506 9730
8507rule__BoundedScopeDefinition__Group_1_1__0__Impl 9731rule__BoundedScope__Group_1_1__0__Impl
8508 @init { 9732 @init {
8509 int stackSize = keepStackSize(); 9733 int stackSize = keepStackSize();
8510 } 9734 }
8511: 9735:
8512( 9736(
8513 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); } 9737 { before(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_1_0()); }
8514 (rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0) 9738 (rule__BoundedScope__UpperBoundAssignment_1_1_0)
8515 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); } 9739 { after(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_1_0()); }
8516) 9740)
8517; 9741;
8518finally { 9742finally {
8519 restoreStackSize(stackSize); 9743 restoreStackSize(stackSize);
8520} 9744}
8521 9745
8522rule__BoundedScopeDefinition__Group_1_1__1 9746rule__BoundedScope__Group_1_1__1
8523 @init { 9747 @init {
8524 int stackSize = keepStackSize(); 9748 int stackSize = keepStackSize();
8525 } 9749 }
8526: 9750:
8527 rule__BoundedScopeDefinition__Group_1_1__1__Impl 9751 rule__BoundedScope__Group_1_1__1__Impl
8528 rule__BoundedScopeDefinition__Group_1_1__2 9752 rule__BoundedScope__Group_1_1__2
8529; 9753;
8530finally { 9754finally {
8531 restoreStackSize(stackSize); 9755 restoreStackSize(stackSize);
8532} 9756}
8533 9757
8534rule__BoundedScopeDefinition__Group_1_1__1__Impl 9758rule__BoundedScope__Group_1_1__1__Impl
8535 @init { 9759 @init {
8536 int stackSize = keepStackSize(); 9760 int stackSize = keepStackSize();
8537 } 9761 }
8538: 9762:
8539( 9763(
8540 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } 9764 { before(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
8541 GreaterThanSignEqualsSign 9765 GreaterThanSignEqualsSign
8542 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } 9766 { after(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
8543) 9767)
8544; 9768;
8545finally { 9769finally {
8546 restoreStackSize(stackSize); 9770 restoreStackSize(stackSize);
8547} 9771}
8548 9772
8549rule__BoundedScopeDefinition__Group_1_1__2 9773rule__BoundedScope__Group_1_1__2
8550 @init { 9774 @init {
8551 int stackSize = keepStackSize(); 9775 int stackSize = keepStackSize();
8552 } 9776 }
8553: 9777:
8554 rule__BoundedScopeDefinition__Group_1_1__2__Impl 9778 rule__BoundedScope__Group_1_1__2__Impl
8555 rule__BoundedScopeDefinition__Group_1_1__3 9779 rule__BoundedScope__Group_1_1__3
8556; 9780;
8557finally { 9781finally {
8558 restoreStackSize(stackSize); 9782 restoreStackSize(stackSize);
8559} 9783}
8560 9784
8561rule__BoundedScopeDefinition__Group_1_1__2__Impl 9785rule__BoundedScope__Group_1_1__2__Impl
8562 @init { 9786 @init {
8563 int stackSize = keepStackSize(); 9787 int stackSize = keepStackSize();
8564 } 9788 }
8565: 9789:
8566( 9790(
8567 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); } 9791 { before(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_1_2()); }
8568 (rule__BoundedScopeDefinition__TypeAssignment_1_1_2) 9792 (rule__BoundedScope__TypeAssignment_1_1_2)
8569 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); } 9793 { after(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_1_2()); }
8570) 9794)
8571; 9795;
8572finally { 9796finally {
8573 restoreStackSize(stackSize); 9797 restoreStackSize(stackSize);
8574} 9798}
8575 9799
8576rule__BoundedScopeDefinition__Group_1_1__3 9800rule__BoundedScope__Group_1_1__3
8577 @init { 9801 @init {
8578 int stackSize = keepStackSize(); 9802 int stackSize = keepStackSize();
8579 } 9803 }
8580: 9804:
8581 rule__BoundedScopeDefinition__Group_1_1__3__Impl 9805 rule__BoundedScope__Group_1_1__3__Impl
8582; 9806;
8583finally { 9807finally {
8584 restoreStackSize(stackSize); 9808 restoreStackSize(stackSize);
8585} 9809}
8586 9810
8587rule__BoundedScopeDefinition__Group_1_1__3__Impl 9811rule__BoundedScope__Group_1_1__3__Impl
8588 @init { 9812 @init {
8589 int stackSize = keepStackSize(); 9813 int stackSize = keepStackSize();
8590 } 9814 }
8591: 9815:
8592( 9816(
8593 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); } 9817 { before(grammarAccess.getBoundedScopeAccess().getGroup_1_1_3()); }
8594 (rule__BoundedScopeDefinition__Group_1_1_3__0)? 9818 (rule__BoundedScope__Group_1_1_3__0)?
8595 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); } 9819 { after(grammarAccess.getBoundedScopeAccess().getGroup_1_1_3()); }
8596) 9820)
8597; 9821;
8598finally { 9822finally {
@@ -8600,53 +9824,53 @@ finally {
8600} 9824}
8601 9825
8602 9826
8603rule__BoundedScopeDefinition__Group_1_1_3__0 9827rule__BoundedScope__Group_1_1_3__0
8604 @init { 9828 @init {
8605 int stackSize = keepStackSize(); 9829 int stackSize = keepStackSize();
8606 } 9830 }
8607: 9831:
8608 rule__BoundedScopeDefinition__Group_1_1_3__0__Impl 9832 rule__BoundedScope__Group_1_1_3__0__Impl
8609 rule__BoundedScopeDefinition__Group_1_1_3__1 9833 rule__BoundedScope__Group_1_1_3__1
8610; 9834;
8611finally { 9835finally {
8612 restoreStackSize(stackSize); 9836 restoreStackSize(stackSize);
8613} 9837}
8614 9838
8615rule__BoundedScopeDefinition__Group_1_1_3__0__Impl 9839rule__BoundedScope__Group_1_1_3__0__Impl
8616 @init { 9840 @init {
8617 int stackSize = keepStackSize(); 9841 int stackSize = keepStackSize();
8618 } 9842 }
8619: 9843:
8620( 9844(
8621 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); } 9845 { before(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); }
8622 GreaterThanSignEqualsSign 9846 GreaterThanSignEqualsSign
8623 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); } 9847 { after(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); }
8624) 9848)
8625; 9849;
8626finally { 9850finally {
8627 restoreStackSize(stackSize); 9851 restoreStackSize(stackSize);
8628} 9852}
8629 9853
8630rule__BoundedScopeDefinition__Group_1_1_3__1 9854rule__BoundedScope__Group_1_1_3__1
8631 @init { 9855 @init {
8632 int stackSize = keepStackSize(); 9856 int stackSize = keepStackSize();
8633 } 9857 }
8634: 9858:
8635 rule__BoundedScopeDefinition__Group_1_1_3__1__Impl 9859 rule__BoundedScope__Group_1_1_3__1__Impl
8636; 9860;
8637finally { 9861finally {
8638 restoreStackSize(stackSize); 9862 restoreStackSize(stackSize);
8639} 9863}
8640 9864
8641rule__BoundedScopeDefinition__Group_1_1_3__1__Impl 9865rule__BoundedScope__Group_1_1_3__1__Impl
8642 @init { 9866 @init {
8643 int stackSize = keepStackSize(); 9867 int stackSize = keepStackSize();
8644 } 9868 }
8645: 9869:
8646( 9870(
8647 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); } 9871 { before(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_1_3_1()); }
8648 (rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1) 9872 (rule__BoundedScope__LowerBoundAssignment_1_1_3_1)
8649 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); } 9873 { after(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_1_3_1()); }
8650) 9874)
8651; 9875;
8652finally { 9876finally {
@@ -8654,53 +9878,80 @@ finally {
8654} 9878}
8655 9879
8656 9880
8657rule__LowerBoundedScopeDefinition__Group__0 9881rule__LowerBoundedScope__Group__0
8658 @init { 9882 @init {
8659 int stackSize = keepStackSize(); 9883 int stackSize = keepStackSize();
8660 } 9884 }
8661: 9885:
8662 rule__LowerBoundedScopeDefinition__Group__0__Impl 9886 rule__LowerBoundedScope__Group__0__Impl
8663 rule__LowerBoundedScopeDefinition__Group__1 9887 rule__LowerBoundedScope__Group__1
8664; 9888;
8665finally { 9889finally {
8666 restoreStackSize(stackSize); 9890 restoreStackSize(stackSize);
8667} 9891}
8668 9892
8669rule__LowerBoundedScopeDefinition__Group__0__Impl 9893rule__LowerBoundedScope__Group__0__Impl
8670 @init { 9894 @init {
8671 int stackSize = keepStackSize(); 9895 int stackSize = keepStackSize();
8672 } 9896 }
8673: 9897:
8674( 9898(
8675 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); } 9899 { before(grammarAccess.getLowerBoundedScopeAccess().getScopeKeyword_0()); }
8676 Scope 9900 Scope
8677 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); } 9901 { after(grammarAccess.getLowerBoundedScopeAccess().getScopeKeyword_0()); }
9902)
9903;
9904finally {
9905 restoreStackSize(stackSize);
9906}
9907
9908rule__LowerBoundedScope__Group__1
9909 @init {
9910 int stackSize = keepStackSize();
9911 }
9912:
9913 rule__LowerBoundedScope__Group__1__Impl
9914 rule__LowerBoundedScope__Group__2
9915;
9916finally {
9917 restoreStackSize(stackSize);
9918}
9919
9920rule__LowerBoundedScope__Group__1__Impl
9921 @init {
9922 int stackSize = keepStackSize();
9923 }
9924:
9925(
9926 { before(grammarAccess.getLowerBoundedScopeAccess().getAlternatives_1()); }
9927 (rule__LowerBoundedScope__Alternatives_1)
9928 { after(grammarAccess.getLowerBoundedScopeAccess().getAlternatives_1()); }
8678) 9929)
8679; 9930;
8680finally { 9931finally {
8681 restoreStackSize(stackSize); 9932 restoreStackSize(stackSize);
8682} 9933}
8683 9934
8684rule__LowerBoundedScopeDefinition__Group__1 9935rule__LowerBoundedScope__Group__2
8685 @init { 9936 @init {
8686 int stackSize = keepStackSize(); 9937 int stackSize = keepStackSize();
8687 } 9938 }
8688: 9939:
8689 rule__LowerBoundedScopeDefinition__Group__1__Impl 9940 rule__LowerBoundedScope__Group__2__Impl
8690; 9941;
8691finally { 9942finally {
8692 restoreStackSize(stackSize); 9943 restoreStackSize(stackSize);
8693} 9944}
8694 9945
8695rule__LowerBoundedScopeDefinition__Group__1__Impl 9946rule__LowerBoundedScope__Group__2__Impl
8696 @init { 9947 @init {
8697 int stackSize = keepStackSize(); 9948 int stackSize = keepStackSize();
8698 } 9949 }
8699: 9950:
8700( 9951(
8701 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); } 9952 { before(grammarAccess.getLowerBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); }
8702 (rule__LowerBoundedScopeDefinition__Alternatives_1) 9953 RULE_FULL_STOP
8703 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); } 9954 { after(grammarAccess.getLowerBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); }
8704) 9955)
8705; 9956;
8706finally { 9957finally {
@@ -8708,80 +9959,80 @@ finally {
8708} 9959}
8709 9960
8710 9961
8711rule__LowerBoundedScopeDefinition__Group_1_0__0 9962rule__LowerBoundedScope__Group_1_0__0
8712 @init { 9963 @init {
8713 int stackSize = keepStackSize(); 9964 int stackSize = keepStackSize();
8714 } 9965 }
8715: 9966:
8716 rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl 9967 rule__LowerBoundedScope__Group_1_0__0__Impl
8717 rule__LowerBoundedScopeDefinition__Group_1_0__1 9968 rule__LowerBoundedScope__Group_1_0__1
8718; 9969;
8719finally { 9970finally {
8720 restoreStackSize(stackSize); 9971 restoreStackSize(stackSize);
8721} 9972}
8722 9973
8723rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl 9974rule__LowerBoundedScope__Group_1_0__0__Impl
8724 @init { 9975 @init {
8725 int stackSize = keepStackSize(); 9976 int stackSize = keepStackSize();
8726 } 9977 }
8727: 9978:
8728( 9979(
8729 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); } 9980 { before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_0_0()); }
8730 (rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0) 9981 (rule__LowerBoundedScope__LowerBoundAssignment_1_0_0)
8731 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); } 9982 { after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_0_0()); }
8732) 9983)
8733; 9984;
8734finally { 9985finally {
8735 restoreStackSize(stackSize); 9986 restoreStackSize(stackSize);
8736} 9987}
8737 9988
8738rule__LowerBoundedScopeDefinition__Group_1_0__1 9989rule__LowerBoundedScope__Group_1_0__1
8739 @init { 9990 @init {
8740 int stackSize = keepStackSize(); 9991 int stackSize = keepStackSize();
8741 } 9992 }
8742: 9993:
8743 rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl 9994 rule__LowerBoundedScope__Group_1_0__1__Impl
8744 rule__LowerBoundedScopeDefinition__Group_1_0__2 9995 rule__LowerBoundedScope__Group_1_0__2
8745; 9996;
8746finally { 9997finally {
8747 restoreStackSize(stackSize); 9998 restoreStackSize(stackSize);
8748} 9999}
8749 10000
8750rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl 10001rule__LowerBoundedScope__Group_1_0__1__Impl
8751 @init { 10002 @init {
8752 int stackSize = keepStackSize(); 10003 int stackSize = keepStackSize();
8753 } 10004 }
8754: 10005:
8755( 10006(
8756 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); } 10007 { before(grammarAccess.getLowerBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_1()); }
8757 LessThanSignEqualsSign 10008 LessThanSignEqualsSign
8758 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); } 10009 { after(grammarAccess.getLowerBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_1()); }
8759) 10010)
8760; 10011;
8761finally { 10012finally {
8762 restoreStackSize(stackSize); 10013 restoreStackSize(stackSize);
8763} 10014}
8764 10015
8765rule__LowerBoundedScopeDefinition__Group_1_0__2 10016rule__LowerBoundedScope__Group_1_0__2
8766 @init { 10017 @init {
8767 int stackSize = keepStackSize(); 10018 int stackSize = keepStackSize();
8768 } 10019 }
8769: 10020:
8770 rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl 10021 rule__LowerBoundedScope__Group_1_0__2__Impl
8771; 10022;
8772finally { 10023finally {
8773 restoreStackSize(stackSize); 10024 restoreStackSize(stackSize);
8774} 10025}
8775 10026
8776rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl 10027rule__LowerBoundedScope__Group_1_0__2__Impl
8777 @init { 10028 @init {
8778 int stackSize = keepStackSize(); 10029 int stackSize = keepStackSize();
8779 } 10030 }
8780: 10031:
8781( 10032(
8782 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); } 10033 { before(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_0_2()); }
8783 (rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2) 10034 (rule__LowerBoundedScope__TypeAssignment_1_0_2)
8784 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); } 10035 { after(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_0_2()); }
8785) 10036)
8786; 10037;
8787finally { 10038finally {
@@ -8789,80 +10040,80 @@ finally {
8789} 10040}
8790 10041
8791 10042
8792rule__LowerBoundedScopeDefinition__Group_1_1__0 10043rule__LowerBoundedScope__Group_1_1__0
8793 @init { 10044 @init {
8794 int stackSize = keepStackSize(); 10045 int stackSize = keepStackSize();
8795 } 10046 }
8796: 10047:
8797 rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl 10048 rule__LowerBoundedScope__Group_1_1__0__Impl
8798 rule__LowerBoundedScopeDefinition__Group_1_1__1 10049 rule__LowerBoundedScope__Group_1_1__1
8799; 10050;
8800finally { 10051finally {
8801 restoreStackSize(stackSize); 10052 restoreStackSize(stackSize);
8802} 10053}
8803 10054
8804rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl 10055rule__LowerBoundedScope__Group_1_1__0__Impl
8805 @init { 10056 @init {
8806 int stackSize = keepStackSize(); 10057 int stackSize = keepStackSize();
8807 } 10058 }
8808: 10059:
8809( 10060(
8810 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); } 10061 { before(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_1_0()); }
8811 (rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0) 10062 (rule__LowerBoundedScope__TypeAssignment_1_1_0)
8812 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); } 10063 { after(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_1_0()); }
8813) 10064)
8814; 10065;
8815finally { 10066finally {
8816 restoreStackSize(stackSize); 10067 restoreStackSize(stackSize);
8817} 10068}
8818 10069
8819rule__LowerBoundedScopeDefinition__Group_1_1__1 10070rule__LowerBoundedScope__Group_1_1__1
8820 @init { 10071 @init {
8821 int stackSize = keepStackSize(); 10072 int stackSize = keepStackSize();
8822 } 10073 }
8823: 10074:
8824 rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl 10075 rule__LowerBoundedScope__Group_1_1__1__Impl
8825 rule__LowerBoundedScopeDefinition__Group_1_1__2 10076 rule__LowerBoundedScope__Group_1_1__2
8826; 10077;
8827finally { 10078finally {
8828 restoreStackSize(stackSize); 10079 restoreStackSize(stackSize);
8829} 10080}
8830 10081
8831rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl 10082rule__LowerBoundedScope__Group_1_1__1__Impl
8832 @init { 10083 @init {
8833 int stackSize = keepStackSize(); 10084 int stackSize = keepStackSize();
8834 } 10085 }
8835: 10086:
8836( 10087(
8837 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } 10088 { before(grammarAccess.getLowerBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
8838 GreaterThanSignEqualsSign 10089 GreaterThanSignEqualsSign
8839 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } 10090 { after(grammarAccess.getLowerBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
8840) 10091)
8841; 10092;
8842finally { 10093finally {
8843 restoreStackSize(stackSize); 10094 restoreStackSize(stackSize);
8844} 10095}
8845 10096
8846rule__LowerBoundedScopeDefinition__Group_1_1__2 10097rule__LowerBoundedScope__Group_1_1__2
8847 @init { 10098 @init {
8848 int stackSize = keepStackSize(); 10099 int stackSize = keepStackSize();
8849 } 10100 }
8850: 10101:
8851 rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl 10102 rule__LowerBoundedScope__Group_1_1__2__Impl
8852; 10103;
8853finally { 10104finally {
8854 restoreStackSize(stackSize); 10105 restoreStackSize(stackSize);
8855} 10106}
8856 10107
8857rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl 10108rule__LowerBoundedScope__Group_1_1__2__Impl
8858 @init { 10109 @init {
8859 int stackSize = keepStackSize(); 10110 int stackSize = keepStackSize();
8860 } 10111 }
8861: 10112:
8862( 10113(
8863 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); } 10114 { before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_1_2()); }
8864 (rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2) 10115 (rule__LowerBoundedScope__LowerBoundAssignment_1_1_2)
8865 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); } 10116 { after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_1_2()); }
8866) 10117)
8867; 10118;
8868finally { 10119finally {
@@ -8870,53 +10121,80 @@ finally {
8870} 10121}
8871 10122
8872 10123
8873rule__ObjectiveDefinition__Group__0 10124rule__ObjectiveDeclaration__Group__0
8874 @init { 10125 @init {
8875 int stackSize = keepStackSize(); 10126 int stackSize = keepStackSize();
8876 } 10127 }
8877: 10128:
8878 rule__ObjectiveDefinition__Group__0__Impl 10129 rule__ObjectiveDeclaration__Group__0__Impl
8879 rule__ObjectiveDefinition__Group__1 10130 rule__ObjectiveDeclaration__Group__1
8880; 10131;
8881finally { 10132finally {
8882 restoreStackSize(stackSize); 10133 restoreStackSize(stackSize);
8883} 10134}
8884 10135
8885rule__ObjectiveDefinition__Group__0__Impl 10136rule__ObjectiveDeclaration__Group__0__Impl
8886 @init { 10137 @init {
8887 int stackSize = keepStackSize(); 10138 int stackSize = keepStackSize();
8888 } 10139 }
8889: 10140:
8890( 10141(
8891 { before(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); } 10142 { before(grammarAccess.getObjectiveDeclarationAccess().getKindAssignment_0()); }
8892 (rule__ObjectiveDefinition__KindAssignment_0) 10143 (rule__ObjectiveDeclaration__KindAssignment_0)
8893 { after(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); } 10144 { after(grammarAccess.getObjectiveDeclarationAccess().getKindAssignment_0()); }
8894) 10145)
8895; 10146;
8896finally { 10147finally {
8897 restoreStackSize(stackSize); 10148 restoreStackSize(stackSize);
8898} 10149}
8899 10150
8900rule__ObjectiveDefinition__Group__1 10151rule__ObjectiveDeclaration__Group__1
8901 @init { 10152 @init {
8902 int stackSize = keepStackSize(); 10153 int stackSize = keepStackSize();
8903 } 10154 }
8904: 10155:
8905 rule__ObjectiveDefinition__Group__1__Impl 10156 rule__ObjectiveDeclaration__Group__1__Impl
10157 rule__ObjectiveDeclaration__Group__2
8906; 10158;
8907finally { 10159finally {
8908 restoreStackSize(stackSize); 10160 restoreStackSize(stackSize);
8909} 10161}
8910 10162
8911rule__ObjectiveDefinition__Group__1__Impl 10163rule__ObjectiveDeclaration__Group__1__Impl
8912 @init { 10164 @init {
8913 int stackSize = keepStackSize(); 10165 int stackSize = keepStackSize();
8914 } 10166 }
8915: 10167:
8916( 10168(
8917 { before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); } 10169 { before(grammarAccess.getObjectiveDeclarationAccess().getObjectiveAssignment_1()); }
8918 (rule__ObjectiveDefinition__ObjectiveAssignment_1) 10170 (rule__ObjectiveDeclaration__ObjectiveAssignment_1)
8919 { after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); } 10171 { after(grammarAccess.getObjectiveDeclarationAccess().getObjectiveAssignment_1()); }
10172)
10173;
10174finally {
10175 restoreStackSize(stackSize);
10176}
10177
10178rule__ObjectiveDeclaration__Group__2
10179 @init {
10180 int stackSize = keepStackSize();
10181 }
10182:
10183 rule__ObjectiveDeclaration__Group__2__Impl
10184;
10185finally {
10186 restoreStackSize(stackSize);
10187}
10188
10189rule__ObjectiveDeclaration__Group__2__Impl
10190 @init {
10191 int stackSize = keepStackSize();
10192 }
10193:
10194(
10195 { before(grammarAccess.getObjectiveDeclarationAccess().getFULL_STOPTerminalRuleCall_2()); }
10196 RULE_FULL_STOP
10197 { after(grammarAccess.getObjectiveDeclarationAccess().getFULL_STOPTerminalRuleCall_2()); }
8920) 10198)
8921; 10199;
8922finally { 10200finally {
@@ -8957,6 +10235,7 @@ rule__Real__Group__1
8957 } 10235 }
8958: 10236:
8959 rule__Real__Group__1__Impl 10237 rule__Real__Group__1__Impl
10238 rule__Real__Group__2
8960; 10239;
8961finally { 10240finally {
8962 restoreStackSize(stackSize); 10241 restoreStackSize(stackSize);
@@ -8968,9 +10247,35 @@ rule__Real__Group__1__Impl
8968 } 10247 }
8969: 10248:
8970( 10249(
8971 { before(grammarAccess.getRealAccess().getGroup_1()); } 10250 { before(grammarAccess.getRealAccess().getFullStopKeyword_1()); }
8972 (rule__Real__Group_1__0)? 10251 FullStop
8973 { after(grammarAccess.getRealAccess().getGroup_1()); } 10252 { after(grammarAccess.getRealAccess().getFullStopKeyword_1()); }
10253)
10254;
10255finally {
10256 restoreStackSize(stackSize);
10257}
10258
10259rule__Real__Group__2
10260 @init {
10261 int stackSize = keepStackSize();
10262 }
10263:
10264 rule__Real__Group__2__Impl
10265;
10266finally {
10267 restoreStackSize(stackSize);
10268}
10269
10270rule__Real__Group__2__Impl
10271 @init {
10272 int stackSize = keepStackSize();
10273 }
10274:
10275(
10276 { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_2()); }
10277 RULE_INT
10278 { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_2()); }
8974) 10279)
8975; 10280;
8976finally { 10281finally {
@@ -8978,53 +10283,53 @@ finally {
8978} 10283}
8979 10284
8980 10285
8981rule__Real__Group_1__0 10286rule__QualifiedName__Group__0
8982 @init { 10287 @init {
8983 int stackSize = keepStackSize(); 10288 int stackSize = keepStackSize();
8984 } 10289 }
8985: 10290:
8986 rule__Real__Group_1__0__Impl 10291 rule__QualifiedName__Group__0__Impl
8987 rule__Real__Group_1__1 10292 rule__QualifiedName__Group__1
8988; 10293;
8989finally { 10294finally {
8990 restoreStackSize(stackSize); 10295 restoreStackSize(stackSize);
8991} 10296}
8992 10297
8993rule__Real__Group_1__0__Impl 10298rule__QualifiedName__Group__0__Impl
8994 @init { 10299 @init {
8995 int stackSize = keepStackSize(); 10300 int stackSize = keepStackSize();
8996 } 10301 }
8997: 10302:
8998( 10303(
8999 { before(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); } 10304 { before(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_0()); }
9000 FullStop 10305 ruleQualifiedNameSegment
9001 { after(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); } 10306 { after(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_0()); }
9002) 10307)
9003; 10308;
9004finally { 10309finally {
9005 restoreStackSize(stackSize); 10310 restoreStackSize(stackSize);
9006} 10311}
9007 10312
9008rule__Real__Group_1__1 10313rule__QualifiedName__Group__1
9009 @init { 10314 @init {
9010 int stackSize = keepStackSize(); 10315 int stackSize = keepStackSize();
9011 } 10316 }
9012: 10317:
9013 rule__Real__Group_1__1__Impl 10318 rule__QualifiedName__Group__1__Impl
9014; 10319;
9015finally { 10320finally {
9016 restoreStackSize(stackSize); 10321 restoreStackSize(stackSize);
9017} 10322}
9018 10323
9019rule__Real__Group_1__1__Impl 10324rule__QualifiedName__Group__1__Impl
9020 @init { 10325 @init {
9021 int stackSize = keepStackSize(); 10326 int stackSize = keepStackSize();
9022 } 10327 }
9023: 10328:
9024( 10329(
9025 { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); } 10330 { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
9026 RULE_INT 10331 (rule__QualifiedName__Group_1__0)*
9027 { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); } 10332 { after(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
9028) 10333)
9029; 10334;
9030finally { 10335finally {
@@ -9032,53 +10337,53 @@ finally {
9032} 10337}
9033 10338
9034 10339
9035rule__QualifiedName__Group_0__0 10340rule__QualifiedName__Group_1__0
9036 @init { 10341 @init {
9037 int stackSize = keepStackSize(); 10342 int stackSize = keepStackSize();
9038 } 10343 }
9039: 10344:
9040 rule__QualifiedName__Group_0__0__Impl 10345 rule__QualifiedName__Group_1__0__Impl
9041 rule__QualifiedName__Group_0__1 10346 rule__QualifiedName__Group_1__1
9042; 10347;
9043finally { 10348finally {
9044 restoreStackSize(stackSize); 10349 restoreStackSize(stackSize);
9045} 10350}
9046 10351
9047rule__QualifiedName__Group_0__0__Impl 10352rule__QualifiedName__Group_1__0__Impl
9048 @init { 10353 @init {
9049 int stackSize = keepStackSize(); 10354 int stackSize = keepStackSize();
9050 } 10355 }
9051: 10356:
9052( 10357(
9053 { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); } 10358 { before(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); }
9054 RULE_ID 10359 ColonColon
9055 { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); } 10360 { after(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); }
9056) 10361)
9057; 10362;
9058finally { 10363finally {
9059 restoreStackSize(stackSize); 10364 restoreStackSize(stackSize);
9060} 10365}
9061 10366
9062rule__QualifiedName__Group_0__1 10367rule__QualifiedName__Group_1__1
9063 @init { 10368 @init {
9064 int stackSize = keepStackSize(); 10369 int stackSize = keepStackSize();
9065 } 10370 }
9066: 10371:
9067 rule__QualifiedName__Group_0__1__Impl 10372 rule__QualifiedName__Group_1__1__Impl
9068; 10373;
9069finally { 10374finally {
9070 restoreStackSize(stackSize); 10375 restoreStackSize(stackSize);
9071} 10376}
9072 10377
9073rule__QualifiedName__Group_0__1__Impl 10378rule__QualifiedName__Group_1__1__Impl
9074 @init { 10379 @init {
9075 int stackSize = keepStackSize(); 10380 int stackSize = keepStackSize();
9076 } 10381 }
9077: 10382:
9078( 10383(
9079 { before(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); } 10384 { before(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_1_1()); }
9080 (rule__QualifiedName__Group_0_1__0)* 10385 ruleQualifiedNameSegment
9081 { after(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); } 10386 { after(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_1_1()); }
9082) 10387)
9083; 10388;
9084finally { 10389finally {
@@ -9086,84 +10391,286 @@ finally {
9086} 10391}
9087 10392
9088 10393
9089rule__QualifiedName__Group_0_1__0 10394rule__ExternPredicateDeclaration__UnorderedGroup_1
9090 @init { 10395 @init {
9091 int stackSize = keepStackSize(); 10396 int stackSize = keepStackSize();
10397 getUnorderedGroupHelper().enter(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1());
9092 } 10398 }
9093: 10399:
9094 rule__QualifiedName__Group_0_1__0__Impl 10400 rule__ExternPredicateDeclaration__UnorderedGroup_1__0
9095 rule__QualifiedName__Group_0_1__1 10401 ?
9096; 10402;
9097finally { 10403finally {
10404 getUnorderedGroupHelper().leave(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1());
9098 restoreStackSize(stackSize); 10405 restoreStackSize(stackSize);
9099} 10406}
9100 10407
9101rule__QualifiedName__Group_0_1__0__Impl 10408rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl
9102 @init { 10409 @init {
9103 int stackSize = keepStackSize(); 10410 int stackSize = keepStackSize();
10411 boolean selected = false;
9104 } 10412 }
9105: 10413:
9106( 10414 (
9107 { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); } 10415 (
9108 FullStop 10416 {getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0)}?=>(
9109 { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); } 10417 {
9110) 10418 getUnorderedGroupHelper().select(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0);
10419 }
10420 {
10421 selected = true;
10422 }
10423 (
10424 { before(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalAssignment_1_0()); }
10425 (rule__ExternPredicateDeclaration__FunctionalAssignment_1_0)
10426 { after(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalAssignment_1_0()); }
10427 )
10428 )
10429 )|
10430 (
10431 {getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1)}?=>(
10432 {
10433 getUnorderedGroupHelper().select(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1);
10434 }
10435 {
10436 selected = true;
10437 }
10438 (
10439 { before(grammarAccess.getExternPredicateDeclarationAccess().getErrorAssignment_1_1()); }
10440 (rule__ExternPredicateDeclaration__ErrorAssignment_1_1)
10441 { after(grammarAccess.getExternPredicateDeclarationAccess().getErrorAssignment_1_1()); }
10442 )
10443 )
10444 )
10445 )
9111; 10446;
9112finally { 10447finally {
10448 if (selected)
10449 getUnorderedGroupHelper().returnFromSelection(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1());
9113 restoreStackSize(stackSize); 10450 restoreStackSize(stackSize);
9114} 10451}
9115 10452
9116rule__QualifiedName__Group_0_1__1 10453rule__ExternPredicateDeclaration__UnorderedGroup_1__0
9117 @init { 10454 @init {
9118 int stackSize = keepStackSize(); 10455 int stackSize = keepStackSize();
9119 } 10456 }
9120: 10457:
9121 rule__QualifiedName__Group_0_1__1__Impl 10458 rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl
10459 rule__ExternPredicateDeclaration__UnorderedGroup_1__1?
9122; 10460;
9123finally { 10461finally {
9124 restoreStackSize(stackSize); 10462 restoreStackSize(stackSize);
9125} 10463}
9126 10464
9127rule__QualifiedName__Group_0_1__1__Impl 10465rule__ExternPredicateDeclaration__UnorderedGroup_1__1
9128 @init { 10466 @init {
9129 int stackSize = keepStackSize(); 10467 int stackSize = keepStackSize();
9130 } 10468 }
9131: 10469:
9132( 10470 rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl
9133 { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); }
9134 RULE_ID
9135 { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); }
9136)
9137; 10471;
9138finally { 10472finally {
9139 restoreStackSize(stackSize); 10473 restoreStackSize(stackSize);
9140} 10474}
9141 10475
9142 10476
9143rule__Problem__StatementsAssignment 10477rule__ClassDeclaration__UnorderedGroup_0
10478 @init {
10479 int stackSize = keepStackSize();
10480 getUnorderedGroupHelper().enter(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0());
10481 }
10482:
10483 rule__ClassDeclaration__UnorderedGroup_0__0
10484 ?
10485;
10486finally {
10487 getUnorderedGroupHelper().leave(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0());
10488 restoreStackSize(stackSize);
10489}
10490
10491rule__ClassDeclaration__UnorderedGroup_0__Impl
10492 @init {
10493 int stackSize = keepStackSize();
10494 boolean selected = false;
10495 }
10496:
10497 (
10498 (
10499 {getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0)}?=>(
10500 {
10501 getUnorderedGroupHelper().select(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0);
10502 }
10503 {
10504 selected = true;
10505 }
10506 (
10507 { before(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0_0()); }
10508 (rule__ClassDeclaration__AbstractAssignment_0_0)
10509 { after(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0_0()); }
10510 )
10511 )
10512 )|
10513 (
10514 {getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1)}?=>(
10515 {
10516 getUnorderedGroupHelper().select(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1);
10517 }
10518 {
10519 selected = true;
10520 }
10521 (
10522 { before(grammarAccess.getClassDeclarationAccess().getRootAssignment_0_1()); }
10523 (rule__ClassDeclaration__RootAssignment_0_1)
10524 { after(grammarAccess.getClassDeclarationAccess().getRootAssignment_0_1()); }
10525 )
10526 )
10527 )
10528 )
10529;
10530finally {
10531 if (selected)
10532 getUnorderedGroupHelper().returnFromSelection(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0());
10533 restoreStackSize(stackSize);
10534}
10535
10536rule__ClassDeclaration__UnorderedGroup_0__0
10537 @init {
10538 int stackSize = keepStackSize();
10539 }
10540:
10541 rule__ClassDeclaration__UnorderedGroup_0__Impl
10542 rule__ClassDeclaration__UnorderedGroup_0__1?
10543;
10544finally {
10545 restoreStackSize(stackSize);
10546}
10547
10548rule__ClassDeclaration__UnorderedGroup_0__1
10549 @init {
10550 int stackSize = keepStackSize();
10551 }
10552:
10553 rule__ClassDeclaration__UnorderedGroup_0__Impl
10554;
10555finally {
10556 restoreStackSize(stackSize);
10557}
10558
10559
10560rule__Problem__NameAssignment_0_1
9144 @init { 10561 @init {
9145 int stackSize = keepStackSize(); 10562 int stackSize = keepStackSize();
9146 } 10563 }
9147: 10564:
9148 ( 10565 (
9149 { before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); } 10566 { before(grammarAccess.getProblemAccess().getNameQualifiedNameParserRuleCall_0_1_0()); }
10567 ruleQualifiedName
10568 { after(grammarAccess.getProblemAccess().getNameQualifiedNameParserRuleCall_0_1_0()); }
10569 )
10570;
10571finally {
10572 restoreStackSize(stackSize);
10573}
10574
10575rule__Problem__ImportsAssignment_1
10576 @init {
10577 int stackSize = keepStackSize();
10578 }
10579:
10580 (
10581 { before(grammarAccess.getProblemAccess().getImportsImportParserRuleCall_1_0()); }
10582 ruleImport
10583 { after(grammarAccess.getProblemAccess().getImportsImportParserRuleCall_1_0()); }
10584 )
10585;
10586finally {
10587 restoreStackSize(stackSize);
10588}
10589
10590rule__Problem__StatementsAssignment_2
10591 @init {
10592 int stackSize = keepStackSize();
10593 }
10594:
10595 (
10596 { before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_2_0()); }
9150 ruleStatement 10597 ruleStatement
9151 { after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); } 10598 { after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_2_0()); }
9152 ) 10599 )
9153; 10600;
9154finally { 10601finally {
9155 restoreStackSize(stackSize); 10602 restoreStackSize(stackSize);
9156} 10603}
9157 10604
9158rule__AssertionOrDefinition__RangeAssignment_1_0_2 10605rule__UriImport__UriAssignment_1
9159 @init { 10606 @init {
9160 int stackSize = keepStackSize(); 10607 int stackSize = keepStackSize();
9161 } 10608 }
9162: 10609:
9163 ( 10610 (
9164 { before(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_2_0()); } 10611 { before(grammarAccess.getUriImportAccess().getUriSTRINGTerminalRuleCall_1_0()); }
10612 RULE_STRING
10613 { after(grammarAccess.getUriImportAccess().getUriSTRINGTerminalRuleCall_1_0()); }
10614 )
10615;
10616finally {
10617 restoreStackSize(stackSize);
10618}
10619
10620rule__UriImport__AliasAssignment_2_1
10621 @init {
10622 int stackSize = keepStackSize();
10623 }
10624:
10625 (
10626 { before(grammarAccess.getUriImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); }
10627 ruleQualifiedName
10628 { after(grammarAccess.getUriImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); }
10629 )
10630;
10631finally {
10632 restoreStackSize(stackSize);
10633}
10634
10635rule__NamespaceImport__ImportedNamespaceAssignment_1
10636 @init {
10637 int stackSize = keepStackSize();
10638 }
10639:
10640 (
10641 { before(grammarAccess.getNamespaceImportAccess().getImportedNamespaceQualifiedNameParserRuleCall_1_0()); }
10642 ruleQualifiedName
10643 { after(grammarAccess.getNamespaceImportAccess().getImportedNamespaceQualifiedNameParserRuleCall_1_0()); }
10644 )
10645;
10646finally {
10647 restoreStackSize(stackSize);
10648}
10649
10650rule__NamespaceImport__AliasAssignment_2_1
10651 @init {
10652 int stackSize = keepStackSize();
10653 }
10654:
10655 (
10656 { before(grammarAccess.getNamespaceImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); }
10657 ruleQualifiedName
10658 { after(grammarAccess.getNamespaceImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); }
10659 )
10660;
10661finally {
10662 restoreStackSize(stackSize);
10663}
10664
10665rule__AssertionOrDefinition__RangeAssignment_1_0_1_1
10666 @init {
10667 int stackSize = keepStackSize();
10668 }
10669:
10670 (
10671 { before(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); }
9165 ruleExpression 10672 ruleExpression
9166 { after(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_2_0()); } 10673 { after(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); }
9167 ) 10674 )
9168; 10675;
9169finally { 10676finally {
@@ -9306,478 +10813,520 @@ finally {
9306 restoreStackSize(stackSize); 10813 restoreStackSize(stackSize);
9307} 10814}
9308 10815
9309rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 10816rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1
9310 @init { 10817 @init {
9311 int stackSize = keepStackSize(); 10818 int stackSize = keepStackSize();
9312 } 10819 }
9313: 10820:
9314 ( 10821 (
9315 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); } 10822 { before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
9316 ruleArgumentList 10823 ruleArgumentList
9317 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); } 10824 { after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
9318 ) 10825 )
9319; 10826;
9320finally { 10827finally {
9321 restoreStackSize(stackSize); 10828 restoreStackSize(stackSize);
9322} 10829}
9323 10830
9324rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 10831rule__UnnamedErrorPredicateDefintion__BodyAssignment_3
9325 @init { 10832 @init {
9326 int stackSize = keepStackSize(); 10833 int stackSize = keepStackSize();
9327 } 10834 }
9328: 10835:
9329 ( 10836 (
9330 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); } 10837 { before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyExpressionParserRuleCall_3_0()); }
9331 ruleExpression 10838 ruleExpression
9332 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); } 10839 { after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyExpressionParserRuleCall_3_0()); }
9333 ) 10840 )
9334; 10841;
9335finally { 10842finally {
9336 restoreStackSize(stackSize); 10843 restoreStackSize(stackSize);
9337} 10844}
9338 10845
9339rule__DefaultDefinition__HeadAssignment_1 10846rule__DefaultAssertion__ExpressionAssignment_1
9340 @init { 10847 @init {
9341 int stackSize = keepStackSize(); 10848 int stackSize = keepStackSize();
9342 } 10849 }
9343: 10850:
9344 ( 10851 (
9345 { before(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); } 10852 { before(grammarAccess.getDefaultAssertionAccess().getExpressionCallParserRuleCall_1_0()); }
9346 ruleCall 10853 ruleCall
9347 { after(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); } 10854 { after(grammarAccess.getDefaultAssertionAccess().getExpressionCallParserRuleCall_1_0()); }
9348 ) 10855 )
9349; 10856;
9350finally { 10857finally {
9351 restoreStackSize(stackSize); 10858 restoreStackSize(stackSize);
9352} 10859}
9353 10860
9354rule__DefaultDefinition__RangeAssignment_3 10861rule__DefaultAssertion__RangeAssignment_2_1
9355 @init { 10862 @init {
9356 int stackSize = keepStackSize(); 10863 int stackSize = keepStackSize();
9357 } 10864 }
9358: 10865:
9359 ( 10866 (
9360 { before(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); } 10867 { before(grammarAccess.getDefaultAssertionAccess().getRangeExpressionParserRuleCall_2_1_0()); }
9361 ruleExpression 10868 ruleExpression
9362 { after(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); } 10869 { after(grammarAccess.getDefaultAssertionAccess().getRangeExpressionParserRuleCall_2_1_0()); }
9363 ) 10870 )
9364; 10871;
9365finally { 10872finally {
9366 restoreStackSize(stackSize); 10873 restoreStackSize(stackSize);
9367} 10874}
9368 10875
9369rule__MetricDefinition__TypeAssignment_0 10876rule__FunctionDefinition__ResultTypeAssignment_0
9370 @init { 10877 @init {
9371 int stackSize = keepStackSize(); 10878 int stackSize = keepStackSize();
9372 } 10879 }
9373: 10880:
9374 ( 10881 (
9375 { before(grammarAccess.getMetricDefinitionAccess().getTypeNamedElementCrossReference_0_0()); } 10882 { before(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolCrossReference_0_0()); }
9376 ( 10883 (
9377 { before(grammarAccess.getMetricDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); } 10884 { before(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
9378 ruleQualifiedName 10885 ruleQualifiedName
9379 { after(grammarAccess.getMetricDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); } 10886 { after(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
9380 ) 10887 )
9381 { after(grammarAccess.getMetricDefinitionAccess().getTypeNamedElementCrossReference_0_0()); } 10888 { after(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolCrossReference_0_0()); }
9382 ) 10889 )
9383; 10890;
9384finally { 10891finally {
9385 restoreStackSize(stackSize); 10892 restoreStackSize(stackSize);
9386} 10893}
9387 10894
9388rule__MetricDefinition__HeadAssignment_1 10895rule__FunctionDefinition__HeadAssignment_1
9389 @init { 10896 @init {
9390 int stackSize = keepStackSize(); 10897 int stackSize = keepStackSize();
9391 } 10898 }
9392: 10899:
9393 ( 10900 (
9394 { before(grammarAccess.getMetricDefinitionAccess().getHeadCallParserRuleCall_1_0()); } 10901 { before(grammarAccess.getFunctionDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
9395 ruleCall 10902 ruleCall
9396 { after(grammarAccess.getMetricDefinitionAccess().getHeadCallParserRuleCall_1_0()); } 10903 { after(grammarAccess.getFunctionDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
9397 ) 10904 )
9398; 10905;
9399finally { 10906finally {
9400 restoreStackSize(stackSize); 10907 restoreStackSize(stackSize);
9401} 10908}
9402 10909
9403rule__MetricDefinition__BodyAssignment_3 10910rule__FunctionDefinition__BodyAssignment_3
9404 @init { 10911 @init {
9405 int stackSize = keepStackSize(); 10912 int stackSize = keepStackSize();
9406 } 10913 }
9407: 10914:
9408 ( 10915 (
9409 { before(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); } 10916 { before(grammarAccess.getFunctionDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
9410 ruleExpression 10917 ruleExpression
9411 { after(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); } 10918 { after(grammarAccess.getFunctionDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
9412 ) 10919 )
9413; 10920;
9414finally { 10921finally {
9415 restoreStackSize(stackSize); 10922 restoreStackSize(stackSize);
9416} 10923}
9417 10924
9418rule__ExternPredicateDefinition__NameAssignment_1 10925rule__TypeReference__TypeAssignment_0
9419 @init { 10926 @init {
9420 int stackSize = keepStackSize(); 10927 int stackSize = keepStackSize();
9421 } 10928 }
9422: 10929:
9423 ( 10930 (
9424 { before(grammarAccess.getExternPredicateDefinitionAccess().getNameQualifiedNameParserRuleCall_1_0()); } 10931 { before(grammarAccess.getTypeReferenceAccess().getTypeSymbolCrossReference_0_0()); }
9425 ruleQualifiedName 10932 (
9426 { after(grammarAccess.getExternPredicateDefinitionAccess().getNameQualifiedNameParserRuleCall_1_0()); } 10933 { before(grammarAccess.getTypeReferenceAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
10934 ruleQualifiedName
10935 { after(grammarAccess.getTypeReferenceAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
10936 )
10937 { after(grammarAccess.getTypeReferenceAccess().getTypeSymbolCrossReference_0_0()); }
9427 ) 10938 )
9428; 10939;
9429finally { 10940finally {
9430 restoreStackSize(stackSize); 10941 restoreStackSize(stackSize);
9431} 10942}
9432 10943
9433rule__ExternPredicateDefinition__ArgumentListAssignment_2 10944rule__TypeReference__ForceObjectTypeAssignment_1
9434 @init { 10945 @init {
9435 int stackSize = keepStackSize(); 10946 int stackSize = keepStackSize();
9436 } 10947 }
9437: 10948:
9438 ( 10949 (
9439 { before(grammarAccess.getExternPredicateDefinitionAccess().getArgumentListArgumentListParserRuleCall_2_0()); } 10950 { before(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); }
9440 ruleArgumentList 10951 (
9441 { after(grammarAccess.getExternPredicateDefinitionAccess().getArgumentListArgumentListParserRuleCall_2_0()); } 10952 { before(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); }
10953 Object
10954 { after(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); }
10955 )
10956 { after(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); }
9442 ) 10957 )
9443; 10958;
9444finally { 10959finally {
9445 restoreStackSize(stackSize); 10960 restoreStackSize(stackSize);
9446} 10961}
9447 10962
9448rule__ExternMetricDefinition__TypeAssignment_1 10963rule__Attribute__KindAssignment_0
9449 @init { 10964 @init {
9450 int stackSize = keepStackSize(); 10965 int stackSize = keepStackSize();
9451 } 10966 }
9452: 10967:
9453 ( 10968 (
9454 { before(grammarAccess.getExternMetricDefinitionAccess().getTypeNamedElementCrossReference_1_0()); } 10969 { before(grammarAccess.getAttributeAccess().getKindAttributeKindEnumRuleCall_0_0()); }
9455 ( 10970 ruleAttributeKind
9456 { before(grammarAccess.getExternMetricDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); } 10971 { after(grammarAccess.getAttributeAccess().getKindAttributeKindEnumRuleCall_0_0()); }
9457 ruleQualifiedName
9458 { after(grammarAccess.getExternMetricDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
9459 )
9460 { after(grammarAccess.getExternMetricDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
9461 ) 10972 )
9462; 10973;
9463finally { 10974finally {
9464 restoreStackSize(stackSize); 10975 restoreStackSize(stackSize);
9465} 10976}
9466 10977
9467rule__ExternMetricDefinition__NameAssignment_2 10978rule__Attribute__TargetAssignment_1
9468 @init { 10979 @init {
9469 int stackSize = keepStackSize(); 10980 int stackSize = keepStackSize();
9470 } 10981 }
9471: 10982:
9472 ( 10983 (
9473 { before(grammarAccess.getExternMetricDefinitionAccess().getNameQualifiedNameParserRuleCall_2_0()); } 10984 { before(grammarAccess.getAttributeAccess().getTargetSymbolCrossReference_1_0()); }
9474 ruleQualifiedName 10985 (
9475 { after(grammarAccess.getExternMetricDefinitionAccess().getNameQualifiedNameParserRuleCall_2_0()); } 10986 { before(grammarAccess.getAttributeAccess().getTargetSymbolQualifiedNameParserRuleCall_1_0_1()); }
10987 ruleQualifiedName
10988 { after(grammarAccess.getAttributeAccess().getTargetSymbolQualifiedNameParserRuleCall_1_0_1()); }
10989 )
10990 { after(grammarAccess.getAttributeAccess().getTargetSymbolCrossReference_1_0()); }
9476 ) 10991 )
9477; 10992;
9478finally { 10993finally {
9479 restoreStackSize(stackSize); 10994 restoreStackSize(stackSize);
9480} 10995}
9481 10996
9482rule__ExternMetricDefinition__ArgumentListAssignment_3 10997rule__ExternPredicateDeclaration__FunctionalAssignment_1_0
9483 @init { 10998 @init {
9484 int stackSize = keepStackSize(); 10999 int stackSize = keepStackSize();
9485 } 11000 }
9486: 11001:
9487 ( 11002 (
9488 { before(grammarAccess.getExternMetricDefinitionAccess().getArgumentListArgumentListParserRuleCall_3_0()); } 11003 { before(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); }
9489 ruleArgumentList 11004 (
9490 { after(grammarAccess.getExternMetricDefinitionAccess().getArgumentListArgumentListParserRuleCall_3_0()); } 11005 { before(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); }
11006 Functional
11007 { after(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); }
11008 )
11009 { after(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); }
9491 ) 11010 )
9492; 11011;
9493finally { 11012finally {
9494 restoreStackSize(stackSize); 11013 restoreStackSize(stackSize);
9495} 11014}
9496 11015
9497rule__ExternAggregatorDefinition__TypeAssignment_1 11016rule__ExternPredicateDeclaration__ErrorAssignment_1_1
9498 @init { 11017 @init {
9499 int stackSize = keepStackSize(); 11018 int stackSize = keepStackSize();
9500 } 11019 }
9501: 11020:
9502 ( 11021 (
9503 { before(grammarAccess.getExternAggregatorDefinitionAccess().getTypeNamedElementCrossReference_1_0()); } 11022 { before(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); }
9504 ( 11023 (
9505 { before(grammarAccess.getExternAggregatorDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); } 11024 { before(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); }
9506 ruleQualifiedName 11025 Error
9507 { after(grammarAccess.getExternAggregatorDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); } 11026 { after(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); }
9508 ) 11027 )
9509 { after(grammarAccess.getExternAggregatorDefinitionAccess().getTypeNamedElementCrossReference_1_0()); } 11028 { after(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); }
9510 ) 11029 )
9511; 11030;
9512finally { 11031finally {
9513 restoreStackSize(stackSize); 11032 restoreStackSize(stackSize);
9514} 11033}
9515 11034
9516rule__ExternAggregatorDefinition__NameAssignment_2 11035rule__ExternPredicateDeclaration__NameAssignment_2
9517 @init { 11036 @init {
9518 int stackSize = keepStackSize(); 11037 int stackSize = keepStackSize();
9519 } 11038 }
9520: 11039:
9521 ( 11040 (
9522 { before(grammarAccess.getExternAggregatorDefinitionAccess().getNameQualifiedNameParserRuleCall_2_0()); } 11041 { before(grammarAccess.getExternPredicateDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
9523 ruleQualifiedName 11042 ruleQualifiedName
9524 { after(grammarAccess.getExternAggregatorDefinitionAccess().getNameQualifiedNameParserRuleCall_2_0()); } 11043 { after(grammarAccess.getExternPredicateDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
9525 ) 11044 )
9526; 11045;
9527finally { 11046finally {
9528 restoreStackSize(stackSize); 11047 restoreStackSize(stackSize);
9529} 11048}
9530 11049
9531rule__ExternAggregatorDefinition__InputTypeAssignment_4 11050rule__ExternPredicateDeclaration__ArgumentListAssignment_3
9532 @init { 11051 @init {
9533 int stackSize = keepStackSize(); 11052 int stackSize = keepStackSize();
9534 } 11053 }
9535: 11054:
9536 ( 11055 (
9537 { before(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeNamedElementCrossReference_4_0()); } 11056 { before(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); }
11057 ruleArgumentList
11058 { after(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); }
11059 )
11060;
11061finally {
11062 restoreStackSize(stackSize);
11063}
11064
11065rule__ExternFunctionDeclaration__ResultTypeAssignment_1
11066 @init {
11067 int stackSize = keepStackSize();
11068 }
11069:
11070 (
11071 { before(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); }
9538 ( 11072 (
9539 { before(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeNamedElementQualifiedNameParserRuleCall_4_0_1()); } 11073 { before(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
9540 ruleQualifiedName 11074 ruleQualifiedName
9541 { after(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeNamedElementQualifiedNameParserRuleCall_4_0_1()); } 11075 { after(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
9542 ) 11076 )
9543 { after(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeNamedElementCrossReference_4_0()); } 11077 { after(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); }
9544 ) 11078 )
9545; 11079;
9546finally { 11080finally {
9547 restoreStackSize(stackSize); 11081 restoreStackSize(stackSize);
9548} 11082}
9549 11083
9550rule__ExternDatatypeDefinition__NameAssignment_2 11084rule__ExternFunctionDeclaration__NameAssignment_2
9551 @init { 11085 @init {
9552 int stackSize = keepStackSize(); 11086 int stackSize = keepStackSize();
9553 } 11087 }
9554: 11088:
9555 ( 11089 (
9556 { before(grammarAccess.getExternDatatypeDefinitionAccess().getNameQualifiedNameParserRuleCall_2_0()); } 11090 { before(grammarAccess.getExternFunctionDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
9557 ruleQualifiedName 11091 ruleQualifiedName
9558 { after(grammarAccess.getExternDatatypeDefinitionAccess().getNameQualifiedNameParserRuleCall_2_0()); } 11092 { after(grammarAccess.getExternFunctionDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
9559 ) 11093 )
9560; 11094;
9561finally { 11095finally {
9562 restoreStackSize(stackSize); 11096 restoreStackSize(stackSize);
9563} 11097}
9564 11098
9565rule__ExternDatatypeDefinition__SupertypesAssignment_3_1 11099rule__ExternFunctionDeclaration__ArgumentListAssignment_3
9566 @init { 11100 @init {
9567 int stackSize = keepStackSize(); 11101 int stackSize = keepStackSize();
9568 } 11102 }
9569: 11103:
9570 ( 11104 (
9571 { before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementCrossReference_3_1_0()); } 11105 { before(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); }
9572 ( 11106 ruleArgumentList
9573 { before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); } 11107 { after(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); }
9574 ruleQualifiedName
9575 { after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); }
9576 )
9577 { after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementCrossReference_3_1_0()); }
9578 ) 11108 )
9579; 11109;
9580finally { 11110finally {
9581 restoreStackSize(stackSize); 11111 restoreStackSize(stackSize);
9582} 11112}
9583 11113
9584rule__ExternDatatypeDefinition__SupertypesAssignment_3_2_1 11114rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1
9585 @init { 11115 @init {
9586 int stackSize = keepStackSize(); 11116 int stackSize = keepStackSize();
9587 } 11117 }
9588: 11118:
9589 ( 11119 (
9590 { before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementCrossReference_3_2_1_0()); } 11120 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); }
9591 ( 11121 (
9592 { before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); } 11122 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
9593 ruleQualifiedName 11123 ruleQualifiedName
9594 { after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); } 11124 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
9595 ) 11125 )
9596 { after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementCrossReference_3_2_1_0()); } 11126 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); }
11127 )
11128;
11129finally {
11130 restoreStackSize(stackSize);
11131}
11132
11133rule__ExternAggregationOperatorDeclaration__NameAssignment_2
11134 @init {
11135 int stackSize = keepStackSize();
11136 }
11137:
11138 (
11139 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
11140 ruleQualifiedName
11141 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
9597 ) 11142 )
9598; 11143;
9599finally { 11144finally {
9600 restoreStackSize(stackSize); 11145 restoreStackSize(stackSize);
9601} 11146}
9602 11147
9603rule__Variable__TypeAssignment_0 11148rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4
9604 @init { 11149 @init {
9605 int stackSize = keepStackSize(); 11150 int stackSize = keepStackSize();
9606 } 11151 }
9607: 11152:
9608 ( 11153 (
9609 { before(grammarAccess.getVariableAccess().getTypeNamedElementCrossReference_0_0()); } 11154 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolCrossReference_4_0()); }
9610 ( 11155 (
9611 { before(grammarAccess.getVariableAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); } 11156 { before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolQualifiedNameParserRuleCall_4_0_1()); }
9612 ruleQualifiedName 11157 ruleQualifiedName
9613 { after(grammarAccess.getVariableAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); } 11158 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolQualifiedNameParserRuleCall_4_0_1()); }
9614 ) 11159 )
9615 { after(grammarAccess.getVariableAccess().getTypeNamedElementCrossReference_0_0()); } 11160 { after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolCrossReference_4_0()); }
9616 ) 11161 )
9617; 11162;
9618finally { 11163finally {
9619 restoreStackSize(stackSize); 11164 restoreStackSize(stackSize);
9620} 11165}
9621 11166
9622rule__Variable__NameAssignment_1 11167rule__ExternDatatypeDeclaration__NameAssignment_2
9623 @init { 11168 @init {
9624 int stackSize = keepStackSize(); 11169 int stackSize = keepStackSize();
9625 } 11170 }
9626: 11171:
9627 ( 11172 (
9628 { before(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_1_0()); } 11173 { before(grammarAccess.getExternDatatypeDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
9629 RULE_ID 11174 ruleQualifiedName
9630 { after(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_1_0()); } 11175 { after(grammarAccess.getExternDatatypeDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
9631 ) 11176 )
9632; 11177;
9633finally { 11178finally {
9634 restoreStackSize(stackSize); 11179 restoreStackSize(stackSize);
9635} 11180}
9636 11181
9637rule__IfElse__ConditionAssignment_1 11182rule__Expression__BodyAssignment_2_1_2
9638 @init { 11183 @init {
9639 int stackSize = keepStackSize(); 11184 int stackSize = keepStackSize();
9640 } 11185 }
9641: 11186:
9642 ( 11187 (
9643 { before(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); } 11188 { before(grammarAccess.getExpressionAccess().getBodyDisjunctiveExpressionParserRuleCall_2_1_2_0()); }
9644 ruleExpression 11189 ruleDisjunctiveExpression
9645 { after(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); } 11190 { after(grammarAccess.getExpressionAccess().getBodyDisjunctiveExpressionParserRuleCall_2_1_2_0()); }
9646 ) 11191 )
9647; 11192;
9648finally { 11193finally {
9649 restoreStackSize(stackSize); 11194 restoreStackSize(stackSize);
9650} 11195}
9651 11196
9652rule__IfElse__ThenAssignment_3 11197rule__ConditionalExpression__ConditionAssignment_1
9653 @init { 11198 @init {
9654 int stackSize = keepStackSize(); 11199 int stackSize = keepStackSize();
9655 } 11200 }
9656: 11201:
9657 ( 11202 (
9658 { before(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); } 11203 { before(grammarAccess.getConditionalExpressionAccess().getConditionDisjunctiveExpressionParserRuleCall_1_0()); }
9659 ruleExpression 11204 ruleDisjunctiveExpression
9660 { after(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); } 11205 { after(grammarAccess.getConditionalExpressionAccess().getConditionDisjunctiveExpressionParserRuleCall_1_0()); }
9661 ) 11206 )
9662; 11207;
9663finally { 11208finally {
9664 restoreStackSize(stackSize); 11209 restoreStackSize(stackSize);
9665} 11210}
9666 11211
9667rule__IfElse__ElseAssignment_5 11212rule__ConditionalExpression__ThenAssignment_3
9668 @init { 11213 @init {
9669 int stackSize = keepStackSize(); 11214 int stackSize = keepStackSize();
9670 } 11215 }
9671: 11216:
9672 ( 11217 (
9673 { before(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); } 11218 { before(grammarAccess.getConditionalExpressionAccess().getThenExpressionParserRuleCall_3_0()); }
9674 ruleExpression 11219 ruleExpression
9675 { after(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); } 11220 { after(grammarAccess.getConditionalExpressionAccess().getThenExpressionParserRuleCall_3_0()); }
9676 ) 11221 )
9677; 11222;
9678finally { 11223finally {
9679 restoreStackSize(stackSize); 11224 restoreStackSize(stackSize);
9680} 11225}
9681 11226
9682rule__Let__BindingsAssignment_1 11227rule__ConditionalExpression__ElseAssignment_5
9683 @init { 11228 @init {
9684 int stackSize = keepStackSize(); 11229 int stackSize = keepStackSize();
9685 } 11230 }
9686: 11231:
9687 ( 11232 (
9688 { before(grammarAccess.getLetAccess().getBindingsLetBindingParserRuleCall_1_0()); } 11233 { before(grammarAccess.getConditionalExpressionAccess().getElseExpressionParserRuleCall_5_0()); }
9689 ruleLetBinding 11234 ruleExpression
9690 { after(grammarAccess.getLetAccess().getBindingsLetBindingParserRuleCall_1_0()); } 11235 { after(grammarAccess.getConditionalExpressionAccess().getElseExpressionParserRuleCall_5_0()); }
9691 ) 11236 )
9692; 11237;
9693finally { 11238finally {
9694 restoreStackSize(stackSize); 11239 restoreStackSize(stackSize);
9695} 11240}
9696 11241
9697rule__Let__BindingsAssignment_2_1 11242rule__LetExpression__BindingsAssignment_1
9698 @init { 11243 @init {
9699 int stackSize = keepStackSize(); 11244 int stackSize = keepStackSize();
9700 } 11245 }
9701: 11246:
9702 ( 11247 (
9703 { before(grammarAccess.getLetAccess().getBindingsLetBindingParserRuleCall_2_1_0()); } 11248 { before(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_1_0()); }
9704 ruleLetBinding 11249 ruleLetBinding
9705 { after(grammarAccess.getLetAccess().getBindingsLetBindingParserRuleCall_2_1_0()); } 11250 { after(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_1_0()); }
9706 ) 11251 )
9707; 11252;
9708finally { 11253finally {
9709 restoreStackSize(stackSize); 11254 restoreStackSize(stackSize);
9710} 11255}
9711 11256
9712rule__Let__BodyAssignment_4 11257rule__LetExpression__BindingsAssignment_2_1
9713 @init { 11258 @init {
9714 int stackSize = keepStackSize(); 11259 int stackSize = keepStackSize();
9715 } 11260 }
9716: 11261:
9717 ( 11262 (
9718 { before(grammarAccess.getLetAccess().getBodyExpressionParserRuleCall_4_0()); } 11263 { before(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_2_1_0()); }
9719 ruleExpression 11264 ruleLetBinding
9720 { after(grammarAccess.getLetAccess().getBodyExpressionParserRuleCall_4_0()); } 11265 { after(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_2_1_0()); }
9721 ) 11266 )
9722; 11267;
9723finally { 11268finally {
9724 restoreStackSize(stackSize); 11269 restoreStackSize(stackSize);
9725} 11270}
9726 11271
9727rule__LetBinding__VariableAssignment_0 11272rule__LetExpression__BodyAssignment_4
9728 @init { 11273 @init {
9729 int stackSize = keepStackSize(); 11274 int stackSize = keepStackSize();
9730 } 11275 }
9731: 11276:
9732 ( 11277 (
9733 { before(grammarAccess.getLetBindingAccess().getVariableVariableParserRuleCall_0_0()); } 11278 { before(grammarAccess.getLetExpressionAccess().getBodyExpressionParserRuleCall_4_0()); }
9734 ruleVariable 11279 ruleExpression
9735 { after(grammarAccess.getLetBindingAccess().getVariableVariableParserRuleCall_0_0()); } 11280 { after(grammarAccess.getLetExpressionAccess().getBodyExpressionParserRuleCall_4_0()); }
9736 ) 11281 )
9737; 11282;
9738finally { 11283finally {
9739 restoreStackSize(stackSize); 11284 restoreStackSize(stackSize);
9740} 11285}
9741 11286
9742rule__LetBinding__ValueAssignment_2 11287rule__LetBinding__TypeAssignment_0
9743 @init { 11288 @init {
9744 int stackSize = keepStackSize(); 11289 int stackSize = keepStackSize();
9745 } 11290 }
9746: 11291:
9747 ( 11292 (
9748 { before(grammarAccess.getLetBindingAccess().getValueAdditiveExpressionParserRuleCall_2_0()); } 11293 { before(grammarAccess.getLetBindingAccess().getTypeSymbolCrossReference_0_0()); }
9749 ruleAdditiveExpression 11294 (
9750 { after(grammarAccess.getLetBindingAccess().getValueAdditiveExpressionParserRuleCall_2_0()); } 11295 { before(grammarAccess.getLetBindingAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
11296 ruleQualifiedName
11297 { after(grammarAccess.getLetBindingAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
11298 )
11299 { after(grammarAccess.getLetBindingAccess().getTypeSymbolCrossReference_0_0()); }
9751 ) 11300 )
9752; 11301;
9753finally { 11302finally {
9754 restoreStackSize(stackSize); 11303 restoreStackSize(stackSize);
9755} 11304}
9756 11305
9757rule__ImplicationExpression__OpAssignment_1_1 11306rule__LetBinding__NameAssignment_1
9758 @init { 11307 @init {
9759 int stackSize = keepStackSize(); 11308 int stackSize = keepStackSize();
9760 } 11309 }
9761: 11310:
9762 ( 11311 (
9763 { before(grammarAccess.getImplicationExpressionAccess().getOpImplicationOperatorEnumRuleCall_1_1_0()); } 11312 { before(grammarAccess.getLetBindingAccess().getNameIDTerminalRuleCall_1_0()); }
9764 ruleImplicationOperator 11313 RULE_ID
9765 { after(grammarAccess.getImplicationExpressionAccess().getOpImplicationOperatorEnumRuleCall_1_1_0()); } 11314 { after(grammarAccess.getLetBindingAccess().getNameIDTerminalRuleCall_1_0()); }
9766 ) 11315 )
9767; 11316;
9768finally { 11317finally {
9769 restoreStackSize(stackSize); 11318 restoreStackSize(stackSize);
9770} 11319}
9771 11320
9772rule__ImplicationExpression__RightAssignment_1_2 11321rule__LetBinding__ValueAssignment_3
9773 @init { 11322 @init {
9774 int stackSize = keepStackSize(); 11323 int stackSize = keepStackSize();
9775 } 11324 }
9776: 11325:
9777 ( 11326 (
9778 { before(grammarAccess.getImplicationExpressionAccess().getRightImplicationExpressionParserRuleCall_1_2_0()); } 11327 { before(grammarAccess.getLetBindingAccess().getValueAdditiveExpressionParserRuleCall_3_0()); }
9779 ruleImplicationExpression 11328 ruleAdditiveExpression
9780 { after(grammarAccess.getImplicationExpressionAccess().getRightImplicationExpressionParserRuleCall_1_2_0()); } 11329 { after(grammarAccess.getLetBindingAccess().getValueAdditiveExpressionParserRuleCall_3_0()); }
9781 ) 11330 )
9782; 11331;
9783finally { 11332finally {
@@ -9994,19 +11543,19 @@ finally {
9994 restoreStackSize(stackSize); 11543 restoreStackSize(stackSize);
9995} 11544}
9996 11545
9997rule__CastExpression__TypeAssignment_1_2 11546rule__CastExpression__TargetTypeAssignment_1_2
9998 @init { 11547 @init {
9999 int stackSize = keepStackSize(); 11548 int stackSize = keepStackSize();
10000 } 11549 }
10001: 11550:
10002 ( 11551 (
10003 { before(grammarAccess.getCastExpressionAccess().getTypeNamedElementCrossReference_1_2_0()); } 11552 { before(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolCrossReference_1_2_0()); }
10004 ( 11553 (
10005 { before(grammarAccess.getCastExpressionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_2_0_1()); } 11554 { before(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolQualifiedNameParserRuleCall_1_2_0_1()); }
10006 ruleQualifiedName 11555 ruleQualifiedName
10007 { after(grammarAccess.getCastExpressionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_2_0_1()); } 11556 { after(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolQualifiedNameParserRuleCall_1_2_0_1()); }
10008 ) 11557 )
10009 { after(grammarAccess.getCastExpressionAccess().getTypeNamedElementCrossReference_1_2_0()); } 11558 { after(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolCrossReference_1_2_0()); }
10010 ) 11559 )
10011; 11560;
10012finally { 11561finally {
@@ -10019,9 +11568,9 @@ rule__UnaryExpression__OpAssignment_1_1
10019 } 11568 }
10020: 11569:
10021 ( 11570 (
10022 { before(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); } 11571 { before(grammarAccess.getUnaryExpressionAccess().getOpUnaryOperatorEnumRuleCall_1_1_0()); }
10023 ruleUnaryOp 11572 ruleUnaryOperator
10024 { after(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); } 11573 { after(grammarAccess.getUnaryExpressionAccess().getOpUnaryOperatorEnumRuleCall_1_1_0()); }
10025 ) 11574 )
10026; 11575;
10027finally { 11576finally {
@@ -10034,593 +11583,608 @@ rule__UnaryExpression__BodyAssignment_1_2
10034 } 11583 }
10035: 11584:
10036 ( 11585 (
10037 { before(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); } 11586 { before(grammarAccess.getUnaryExpressionAccess().getBodyBracedAggregateExpressionParserRuleCall_1_2_0()); }
10038 ruleAggregationExpression 11587 ruleBracedAggregateExpression
10039 { after(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); } 11588 { after(grammarAccess.getUnaryExpressionAccess().getBodyBracedAggregateExpressionParserRuleCall_1_2_0()); }
10040 ) 11589 )
10041; 11590;
10042finally { 11591finally {
10043 restoreStackSize(stackSize); 11592 restoreStackSize(stackSize);
10044} 11593}
10045 11594
10046rule__LocalVariables__VariablesAssignment_2_0 11595rule__Aggregation__OpAssignment_0
10047 @init { 11596 @init {
10048 int stackSize = keepStackSize(); 11597 int stackSize = keepStackSize();
10049 } 11598 }
10050: 11599:
10051 ( 11600 (
10052 { before(grammarAccess.getLocalVariablesAccess().getVariablesVariableParserRuleCall_2_0_0()); } 11601 { before(grammarAccess.getAggregationAccess().getOpSymbolCrossReference_0_0()); }
10053 ruleVariable 11602 (
10054 { after(grammarAccess.getLocalVariablesAccess().getVariablesVariableParserRuleCall_2_0_0()); } 11603 { before(grammarAccess.getAggregationAccess().getOpSymbolQualifiedNameParserRuleCall_0_0_1()); }
11604 ruleQualifiedName
11605 { after(grammarAccess.getAggregationAccess().getOpSymbolQualifiedNameParserRuleCall_0_0_1()); }
11606 )
11607 { after(grammarAccess.getAggregationAccess().getOpSymbolCrossReference_0_0()); }
10055 ) 11608 )
10056; 11609;
10057finally { 11610finally {
10058 restoreStackSize(stackSize); 11611 restoreStackSize(stackSize);
10059} 11612}
10060 11613
10061rule__LocalVariables__VariablesAssignment_2_1_1 11614rule__Aggregation__ValueAssignment_2
10062 @init { 11615 @init {
10063 int stackSize = keepStackSize(); 11616 int stackSize = keepStackSize();
10064 } 11617 }
10065: 11618:
10066 ( 11619 (
10067 { before(grammarAccess.getLocalVariablesAccess().getVariablesVariableParserRuleCall_2_1_1_0()); } 11620 { before(grammarAccess.getAggregationAccess().getValueExpressionParserRuleCall_2_0()); }
10068 ruleVariable 11621 ruleExpression
10069 { after(grammarAccess.getLocalVariablesAccess().getVariablesVariableParserRuleCall_2_1_1_0()); } 11622 { after(grammarAccess.getAggregationAccess().getValueExpressionParserRuleCall_2_0()); }
10070 ) 11623 )
10071; 11624;
10072finally { 11625finally {
10073 restoreStackSize(stackSize); 11626 restoreStackSize(stackSize);
10074} 11627}
10075 11628
10076rule__QuantifiedExpression__QuantifierAssignment_0 11629rule__Aggregation__ConditionAssignment_4
10077 @init { 11630 @init {
10078 int stackSize = keepStackSize(); 11631 int stackSize = keepStackSize();
10079 } 11632 }
10080: 11633:
10081 ( 11634 (
10082 { before(grammarAccess.getQuantifiedExpressionAccess().getQuantifierQuantifierEnumRuleCall_0_0()); } 11635 { before(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); }
10083 ruleQuantifier 11636 ruleExpression
10084 { after(grammarAccess.getQuantifiedExpressionAccess().getQuantifierQuantifierEnumRuleCall_0_0()); } 11637 { after(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); }
10085 ) 11638 )
10086; 11639;
10087finally { 11640finally {
10088 restoreStackSize(stackSize); 11641 restoreStackSize(stackSize);
10089} 11642}
10090 11643
10091rule__QuantifiedExpression__LocalVariablesAssignment_1 11644rule__Count__ConditionAssignment_2
10092 @init { 11645 @init {
10093 int stackSize = keepStackSize(); 11646 int stackSize = keepStackSize();
10094 } 11647 }
10095: 11648:
10096 ( 11649 (
10097 { before(grammarAccess.getQuantifiedExpressionAccess().getLocalVariablesLocalVariablesParserRuleCall_1_0()); } 11650 { before(grammarAccess.getCountAccess().getConditionExpressionParserRuleCall_2_0()); }
10098 ruleLocalVariables 11651 ruleExpression
10099 { after(grammarAccess.getQuantifiedExpressionAccess().getLocalVariablesLocalVariablesParserRuleCall_1_0()); } 11652 { after(grammarAccess.getCountAccess().getConditionExpressionParserRuleCall_2_0()); }
10100 ) 11653 )
10101; 11654;
10102finally { 11655finally {
10103 restoreStackSize(stackSize); 11656 restoreStackSize(stackSize);
10104} 11657}
10105 11658
10106rule__QuantifiedExpression__BodyAssignment_3 11659rule__Call__FunctorAssignment_0
10107 @init { 11660 @init {
10108 int stackSize = keepStackSize(); 11661 int stackSize = keepStackSize();
10109 } 11662 }
10110: 11663:
10111 ( 11664 (
10112 { before(grammarAccess.getQuantifiedExpressionAccess().getBodyExpressionParserRuleCall_3_0()); } 11665 { before(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); }
10113 ruleExpression 11666 ruleReference
10114 { after(grammarAccess.getQuantifiedExpressionAccess().getBodyExpressionParserRuleCall_3_0()); } 11667 { after(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); }
10115 ) 11668 )
10116; 11669;
10117finally { 11670finally {
10118 restoreStackSize(stackSize); 11671 restoreStackSize(stackSize);
10119} 11672}
10120 11673
10121rule__Aggregation__OpAssignment_0 11674rule__Call__ArgumentListAssignment_1
10122 @init { 11675 @init {
10123 int stackSize = keepStackSize(); 11676 int stackSize = keepStackSize();
10124 } 11677 }
10125: 11678:
10126 ( 11679 (
10127 { before(grammarAccess.getAggregationAccess().getOpNamedElementCrossReference_0_0()); } 11680 { before(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
10128 ( 11681 ruleArgumentList
10129 { before(grammarAccess.getAggregationAccess().getOpNamedElementQualifiedNameParserRuleCall_0_0_1()); } 11682 { after(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
10130 ruleQualifiedName
10131 { after(grammarAccess.getAggregationAccess().getOpNamedElementQualifiedNameParserRuleCall_0_0_1()); }
10132 )
10133 { after(grammarAccess.getAggregationAccess().getOpNamedElementCrossReference_0_0()); }
10134 ) 11683 )
10135; 11684;
10136finally { 11685finally {
10137 restoreStackSize(stackSize); 11686 restoreStackSize(stackSize);
10138} 11687}
10139 11688
10140rule__Aggregation__LocalVariablesAssignment_1 11689rule__ArgumentList__ArgumentsAssignment_2_0
10141 @init { 11690 @init {
10142 int stackSize = keepStackSize(); 11691 int stackSize = keepStackSize();
10143 } 11692 }
10144: 11693:
10145 ( 11694 (
10146 { before(grammarAccess.getAggregationAccess().getLocalVariablesLocalVariablesParserRuleCall_1_0()); } 11695 { before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); }
10147 ruleLocalVariables 11696 ruleArgument
10148 { after(grammarAccess.getAggregationAccess().getLocalVariablesLocalVariablesParserRuleCall_1_0()); } 11697 { after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); }
10149 ) 11698 )
10150; 11699;
10151finally { 11700finally {
10152 restoreStackSize(stackSize); 11701 restoreStackSize(stackSize);
10153} 11702}
10154 11703
10155rule__Aggregation__BodyAssignment_3 11704rule__ArgumentList__ArgumentsAssignment_2_1_1
10156 @init { 11705 @init {
10157 int stackSize = keepStackSize(); 11706 int stackSize = keepStackSize();
10158 } 11707 }
10159: 11708:
10160 ( 11709 (
10161 { before(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_3_0()); } 11710 { before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); }
10162 ruleExpression 11711 ruleArgument
10163 { after(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_3_0()); } 11712 { after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); }
10164 ) 11713 )
10165; 11714;
10166finally { 11715finally {
10167 restoreStackSize(stackSize); 11716 restoreStackSize(stackSize);
10168} 11717}
10169 11718
10170rule__Aggregation__ConditionAssignment_4_1 11719rule__ExpressionArgument__ExpressionAssignment
10171 @init { 11720 @init {
10172 int stackSize = keepStackSize(); 11721 int stackSize = keepStackSize();
10173 } 11722 }
10174: 11723:
10175 ( 11724 (
10176 { before(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_1_0()); } 11725 { before(grammarAccess.getExpressionArgumentAccess().getExpressionComparisonExpressionParserRuleCall_0()); }
10177 ruleExpression 11726 ruleComparisonExpression
10178 { after(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_1_0()); } 11727 { after(grammarAccess.getExpressionArgumentAccess().getExpressionComparisonExpressionParserRuleCall_0()); }
10179 ) 11728 )
10180; 11729;
10181finally { 11730finally {
10182 restoreStackSize(stackSize); 11731 restoreStackSize(stackSize);
10183} 11732}
10184 11733
10185rule__Call__FunctorAssignment_0 11734rule__TypedVariableArgument__TypeReferenceAssignment_0
10186 @init { 11735 @init {
10187 int stackSize = keepStackSize(); 11736 int stackSize = keepStackSize();
10188 } 11737 }
10189: 11738:
10190 ( 11739 (
10191 { before(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); } 11740 { before(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); }
10192 ruleReference 11741 ruleTypeReference
10193 { after(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); } 11742 { after(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); }
10194 ) 11743 )
10195; 11744;
10196finally { 11745finally {
10197 restoreStackSize(stackSize); 11746 restoreStackSize(stackSize);
10198} 11747}
10199 11748
10200rule__Call__TransitiveClosureAssignment_1_0 11749rule__TypedVariableArgument__NameAssignment_1
10201 @init { 11750 @init {
10202 int stackSize = keepStackSize(); 11751 int stackSize = keepStackSize();
10203 } 11752 }
10204: 11753:
10205 ( 11754 (
10206 { before(grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); } 11755 { before(grammarAccess.getTypedVariableArgumentAccess().getNameIDTerminalRuleCall_1_0()); }
10207 RULE_TRANSITIVE_CLOSURE 11756 RULE_ID
10208 { after(grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); } 11757 { after(grammarAccess.getTypedVariableArgumentAccess().getNameIDTerminalRuleCall_1_0()); }
10209 ) 11758 )
10210; 11759;
10211finally { 11760finally {
10212 restoreStackSize(stackSize); 11761 restoreStackSize(stackSize);
10213} 11762}
10214 11763
10215rule__Call__ReflexiveTransitiveClosureAssignment_1_1 11764rule__TypedStarArgument__TypeReferenceAssignment_0
10216 @init { 11765 @init {
10217 int stackSize = keepStackSize(); 11766 int stackSize = keepStackSize();
10218 } 11767 }
10219: 11768:
10220 ( 11769 (
10221 { before(grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); } 11770 { before(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); }
10222 RULE_REFLEXIVE_TRANSITIVE_CLOSURE 11771 ruleTypeReference
10223 { after(grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); } 11772 { after(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); }
10224 ) 11773 )
10225; 11774;
10226finally { 11775finally {
10227 restoreStackSize(stackSize); 11776 restoreStackSize(stackSize);
10228} 11777}
10229 11778
10230rule__Call__ArgumentListAssignment_2 11779rule__Reference__ComponentsAssignment_0
10231 @init { 11780 @init {
10232 int stackSize = keepStackSize(); 11781 int stackSize = keepStackSize();
10233 } 11782 }
10234: 11783:
10235 ( 11784 (
10236 { before(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); } 11785 { before(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_0_0()); }
10237 ruleArgumentList 11786 rulePathComponent
10238 { after(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); } 11787 { after(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_0_0()); }
10239 ) 11788 )
10240; 11789;
10241finally { 11790finally {
10242 restoreStackSize(stackSize); 11791 restoreStackSize(stackSize);
10243} 11792}
10244 11793
10245rule__ArgumentList__ArgumentsAssignment_2_0 11794rule__Reference__ComponentsAssignment_1_1
10246 @init { 11795 @init {
10247 int stackSize = keepStackSize(); 11796 int stackSize = keepStackSize();
10248 } 11797 }
10249: 11798:
10250 ( 11799 (
10251 { before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); } 11800 { before(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_1_1_0()); }
10252 ruleArgument 11801 rulePathComponent
10253 { after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); } 11802 { after(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_1_1_0()); }
10254 ) 11803 )
10255; 11804;
10256finally { 11805finally {
10257 restoreStackSize(stackSize); 11806 restoreStackSize(stackSize);
10258} 11807}
10259 11808
10260rule__ArgumentList__ArgumentsAssignment_2_1_1 11809rule__PathComponent__InverseAssignment_0
10261 @init { 11810 @init {
10262 int stackSize = keepStackSize(); 11811 int stackSize = keepStackSize();
10263 } 11812 }
10264: 11813:
10265 ( 11814 (
10266 { before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); } 11815 { before(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); }
10267 ruleArgument 11816 (
10268 { after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); } 11817 { before(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); }
11818 Tilde
11819 { after(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); }
11820 )
11821 { after(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); }
10269 ) 11822 )
10270; 11823;
10271finally { 11824finally {
10272 restoreStackSize(stackSize); 11825 restoreStackSize(stackSize);
10273} 11826}
10274 11827
10275rule__ExpressionArgument__BodyAssignment 11828rule__PathComponent__SymbolAssignment_1
10276 @init { 11829 @init {
10277 int stackSize = keepStackSize(); 11830 int stackSize = keepStackSize();
10278 } 11831 }
10279: 11832:
10280 ( 11833 (
10281 { before(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); } 11834 { before(grammarAccess.getPathComponentAccess().getSymbolSymbolCrossReference_1_0()); }
10282 ruleComparisonExpression 11835 (
10283 { after(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); } 11836 { before(grammarAccess.getPathComponentAccess().getSymbolSymbolQualifiedNameParserRuleCall_1_0_1()); }
11837 ruleQualifiedName
11838 { after(grammarAccess.getPathComponentAccess().getSymbolSymbolQualifiedNameParserRuleCall_1_0_1()); }
11839 )
11840 { after(grammarAccess.getPathComponentAccess().getSymbolSymbolCrossReference_1_0()); }
10284 ) 11841 )
10285; 11842;
10286finally { 11843finally {
10287 restoreStackSize(stackSize); 11844 restoreStackSize(stackSize);
10288} 11845}
10289 11846
10290rule__TypedArgument__TypeAssignment_0 11847rule__PathComponent__TransitiveClosureAssignment_2_0
10291 @init { 11848 @init {
10292 int stackSize = keepStackSize(); 11849 int stackSize = keepStackSize();
10293 } 11850 }
10294: 11851:
10295 ( 11852 (
10296 { before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); } 11853 { before(grammarAccess.getPathComponentAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_2_0_0()); }
10297 ( 11854 RULE_TRANSITIVE_CLOSURE
10298 { before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); } 11855 { after(grammarAccess.getPathComponentAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_2_0_0()); }
10299 ruleQualifiedName
10300 { after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
10301 )
10302 { after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
10303 ) 11856 )
10304; 11857;
10305finally { 11858finally {
10306 restoreStackSize(stackSize); 11859 restoreStackSize(stackSize);
10307} 11860}
10308 11861
10309rule__TypedArgument__VariableAssignment_1 11862rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1
10310 @init { 11863 @init {
10311 int stackSize = keepStackSize(); 11864 int stackSize = keepStackSize();
10312 } 11865 }
10313: 11866:
10314 ( 11867 (
10315 { before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); } 11868 { before(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_2_1_0()); }
10316 ( 11869 RULE_REFLEXIVE_TRANSITIVE_CLOSURE
10317 { before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); } 11870 { after(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_2_1_0()); }
10318 ruleQualifiedName
10319 { after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); }
10320 )
10321 { after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); }
10322 ) 11871 )
10323; 11872;
10324finally { 11873finally {
10325 restoreStackSize(stackSize); 11874 restoreStackSize(stackSize);
10326} 11875}
10327 11876
10328rule__TypedStarArgument__TypeAssignment_0 11877rule__Interval__LowerBoundAssignment_1
10329 @init { 11878 @init {
10330 int stackSize = keepStackSize(); 11879 int stackSize = keepStackSize();
10331 } 11880 }
10332: 11881:
10333 ( 11882 (
10334 { before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); } 11883 { before(grammarAccess.getIntervalAccess().getLowerBoundAdditiveExpressionParserRuleCall_1_0()); }
10335 ( 11884 ruleAdditiveExpression
10336 { before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); } 11885 { after(grammarAccess.getIntervalAccess().getLowerBoundAdditiveExpressionParserRuleCall_1_0()); }
10337 ruleQualifiedName
10338 { after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
10339 )
10340 { after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
10341 ) 11886 )
10342; 11887;
10343finally { 11888finally {
10344 restoreStackSize(stackSize); 11889 restoreStackSize(stackSize);
10345} 11890}
10346 11891
10347rule__Reference__ReferredAssignment 11892rule__Interval__UpperBoundAssignment_3
10348 @init { 11893 @init {
10349 int stackSize = keepStackSize(); 11894 int stackSize = keepStackSize();
10350 } 11895 }
10351: 11896:
10352 ( 11897 (
10353 { before(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); } 11898 { before(grammarAccess.getIntervalAccess().getUpperBoundAdditiveExpressionParserRuleCall_3_0()); }
10354 ( 11899 ruleAdditiveExpression
10355 { before(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); } 11900 { after(grammarAccess.getIntervalAccess().getUpperBoundAdditiveExpressionParserRuleCall_3_0()); }
10356 ruleQualifiedName
10357 { after(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); }
10358 )
10359 { after(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); }
10360 ) 11901 )
10361; 11902;
10362finally { 11903finally {
10363 restoreStackSize(stackSize); 11904 restoreStackSize(stackSize);
10364} 11905}
10365 11906
10366rule__Interval__LowerBoundAssignment_1 11907rule__LogicLiteral__ValueAssignment
10367 @init { 11908 @init {
10368 int stackSize = keepStackSize(); 11909 int stackSize = keepStackSize();
10369 } 11910 }
10370: 11911:
10371 ( 11912 (
10372 { before(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); } 11913 { before(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); }
10373 ruleExpression 11914 ruleLogicValue
10374 { after(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); } 11915 { after(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); }
10375 ) 11916 )
10376; 11917;
10377finally { 11918finally {
10378 restoreStackSize(stackSize); 11919 restoreStackSize(stackSize);
10379} 11920}
10380 11921
10381rule__Interval__UpperBoundAssignment_3 11922rule__IntLiteral__ValueAssignment
10382 @init { 11923 @init {
10383 int stackSize = keepStackSize(); 11924 int stackSize = keepStackSize();
10384 } 11925 }
10385: 11926:
10386 ( 11927 (
10387 { before(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); } 11928 { before(grammarAccess.getIntLiteralAccess().getValueINTTerminalRuleCall_0()); }
10388 ruleExpression 11929 RULE_INT
10389 { after(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); } 11930 { after(grammarAccess.getIntLiteralAccess().getValueINTTerminalRuleCall_0()); }
10390 ) 11931 )
10391; 11932;
10392finally { 11933finally {
10393 restoreStackSize(stackSize); 11934 restoreStackSize(stackSize);
10394} 11935}
10395 11936
10396rule__LogicLiteral__ValueAssignment 11937rule__RealLiteral__ValueAssignment
10397 @init { 11938 @init {
10398 int stackSize = keepStackSize(); 11939 int stackSize = keepStackSize();
10399 } 11940 }
10400: 11941:
10401 ( 11942 (
10402 { before(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); } 11943 { before(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_0()); }
10403 ruleLogicValue 11944 ruleReal
10404 { after(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); } 11945 { after(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_0()); }
10405 ) 11946 )
10406; 11947;
10407finally { 11948finally {
10408 restoreStackSize(stackSize); 11949 restoreStackSize(stackSize);
10409} 11950}
10410 11951
10411rule__NumericLiteral__ValueAssignment 11952rule__StringLiteral__ValueAssignment
10412 @init { 11953 @init {
10413 int stackSize = keepStackSize(); 11954 int stackSize = keepStackSize();
10414 } 11955 }
10415: 11956:
10416 ( 11957 (
10417 { before(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); } 11958 { before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); }
10418 ruleReal 11959 RULE_STRING
10419 { after(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); } 11960 { after(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); }
10420 ) 11961 )
10421; 11962;
10422finally { 11963finally {
10423 restoreStackSize(stackSize); 11964 restoreStackSize(stackSize);
10424} 11965}
10425 11966
10426rule__StringLiteral__ValueAssignment 11967rule__ClassDeclaration__AbstractAssignment_0_0
10427 @init { 11968 @init {
10428 int stackSize = keepStackSize(); 11969 int stackSize = keepStackSize();
10429 } 11970 }
10430: 11971:
10431 ( 11972 (
10432 { before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); } 11973 { before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); }
10433 RULE_STRING 11974 (
10434 { after(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); } 11975 { before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); }
11976 Abstract
11977 { after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); }
11978 )
11979 { after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); }
10435 ) 11980 )
10436; 11981;
10437finally { 11982finally {
10438 restoreStackSize(stackSize); 11983 restoreStackSize(stackSize);
10439} 11984}
10440 11985
10441rule__ClassDefinition__AbstractAssignment_0 11986rule__ClassDeclaration__RootAssignment_0_1
10442 @init { 11987 @init {
10443 int stackSize = keepStackSize(); 11988 int stackSize = keepStackSize();
10444 } 11989 }
10445: 11990:
10446 ( 11991 (
10447 { before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } 11992 { before(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); }
10448 ( 11993 (
10449 { before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } 11994 { before(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); }
10450 Abstract 11995 Root
10451 { after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } 11996 { after(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); }
10452 ) 11997 )
10453 { after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } 11998 { after(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); }
10454 ) 11999 )
10455; 12000;
10456finally { 12001finally {
10457 restoreStackSize(stackSize); 12002 restoreStackSize(stackSize);
10458} 12003}
10459 12004
10460rule__ClassDefinition__NameAssignment_2 12005rule__ClassDeclaration__NameAssignment_2
10461 @init { 12006 @init {
10462 int stackSize = keepStackSize(); 12007 int stackSize = keepStackSize();
10463 } 12008 }
10464: 12009:
10465 ( 12010 (
10466 { before(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); } 12011 { before(grammarAccess.getClassDeclarationAccess().getNameIDTerminalRuleCall_2_0()); }
10467 RULE_ID 12012 RULE_ID
10468 { after(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); } 12013 { after(grammarAccess.getClassDeclarationAccess().getNameIDTerminalRuleCall_2_0()); }
10469 ) 12014 )
10470; 12015;
10471finally { 12016finally {
10472 restoreStackSize(stackSize); 12017 restoreStackSize(stackSize);
10473} 12018}
10474 12019
10475rule__ClassDefinition__SuperclassesAssignment_3_1 12020rule__ClassDeclaration__SupertypesAssignment_3_1
10476 @init { 12021 @init {
10477 int stackSize = keepStackSize(); 12022 int stackSize = keepStackSize();
10478 } 12023 }
10479: 12024:
10480 ( 12025 (
10481 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); } 12026 { before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_1_0()); }
10482 ( 12027 (
10483 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); } 12028 { before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_1_0_1()); }
10484 ruleQualifiedName 12029 ruleQualifiedName
10485 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); } 12030 { after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_1_0_1()); }
10486 ) 12031 )
10487 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); } 12032 { after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_1_0()); }
10488 ) 12033 )
10489; 12034;
10490finally { 12035finally {
10491 restoreStackSize(stackSize); 12036 restoreStackSize(stackSize);
10492} 12037}
10493 12038
10494rule__ClassDefinition__SuperclassesAssignment_3_2_1 12039rule__ClassDeclaration__SupertypesAssignment_3_2_1
10495 @init { 12040 @init {
10496 int stackSize = keepStackSize(); 12041 int stackSize = keepStackSize();
10497 } 12042 }
10498: 12043:
10499 ( 12044 (
10500 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); } 12045 { before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_2_1_0()); }
10501 ( 12046 (
10502 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); } 12047 { before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_2_1_0_1()); }
10503 ruleQualifiedName 12048 ruleQualifiedName
10504 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); } 12049 { after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_2_1_0_1()); }
10505 ) 12050 )
10506 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); } 12051 { after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_2_1_0()); }
10507 ) 12052 )
10508; 12053;
10509finally { 12054finally {
10510 restoreStackSize(stackSize); 12055 restoreStackSize(stackSize);
10511} 12056}
10512 12057
10513rule__ClassDefinition__MembersAssignment_5 12058rule__ClassDeclaration__FieldsAssignment_4_0_1
10514 @init { 12059 @init {
10515 int stackSize = keepStackSize(); 12060 int stackSize = keepStackSize();
10516 } 12061 }
10517: 12062:
10518 ( 12063 (
10519 { before(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); } 12064 { before(grammarAccess.getClassDeclarationAccess().getFieldsFieldParserRuleCall_4_0_1_0()); }
10520 ruleMemberDefinition 12065 ruleField
10521 { after(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); } 12066 { after(grammarAccess.getClassDeclarationAccess().getFieldsFieldParserRuleCall_4_0_1_0()); }
10522 ) 12067 )
10523; 12068;
10524finally { 12069finally {
10525 restoreStackSize(stackSize); 12070 restoreStackSize(stackSize);
10526} 12071}
10527 12072
10528rule__MemberDefinition__ContainmentAssignment_0 12073rule__Field__ContainmentAssignment_0_0
10529 @init { 12074 @init {
10530 int stackSize = keepStackSize(); 12075 int stackSize = keepStackSize();
10531 } 12076 }
10532: 12077:
10533 ( 12078 (
10534 { before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } 12079 { before(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); }
10535 ( 12080 (
10536 { before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } 12081 { before(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); }
10537 Contains 12082 Contains
10538 { after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } 12083 { after(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); }
12084 )
12085 { after(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); }
12086 )
12087;
12088finally {
12089 restoreStackSize(stackSize);
12090}
12091
12092rule__Field__CrossReferenceAssignment_0_1
12093 @init {
12094 int stackSize = keepStackSize();
12095 }
12096:
12097 (
12098 { before(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); }
12099 (
12100 { before(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); }
12101 Refers
12102 { after(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); }
10539 ) 12103 )
10540 { after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } 12104 { after(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); }
10541 ) 12105 )
10542; 12106;
10543finally { 12107finally {
10544 restoreStackSize(stackSize); 12108 restoreStackSize(stackSize);
10545} 12109}
10546 12110
10547rule__MemberDefinition__TypeAssignment_1 12111rule__Field__TypeAssignment_1
10548 @init { 12112 @init {
10549 int stackSize = keepStackSize(); 12113 int stackSize = keepStackSize();
10550 } 12114 }
10551: 12115:
10552 ( 12116 (
10553 { before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); } 12117 { before(grammarAccess.getFieldAccess().getTypeSymbolCrossReference_1_0()); }
10554 ( 12118 (
10555 { before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); } 12119 { before(grammarAccess.getFieldAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
10556 ruleQualifiedName 12120 ruleQualifiedName
10557 { after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); } 12121 { after(grammarAccess.getFieldAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
10558 ) 12122 )
10559 { after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); } 12123 { after(grammarAccess.getFieldAccess().getTypeSymbolCrossReference_1_0()); }
10560 ) 12124 )
10561; 12125;
10562finally { 12126finally {
10563 restoreStackSize(stackSize); 12127 restoreStackSize(stackSize);
10564} 12128}
10565 12129
10566rule__MemberDefinition__MultiplicityAssignment_2 12130rule__Field__MultiplicityAssignment_2
10567 @init { 12131 @init {
10568 int stackSize = keepStackSize(); 12132 int stackSize = keepStackSize();
10569 } 12133 }
10570: 12134:
10571 ( 12135 (
10572 { before(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); } 12136 { before(grammarAccess.getFieldAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); }
10573 ruleMultiplicity 12137 ruleMultiplicity
10574 { after(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); } 12138 { after(grammarAccess.getFieldAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); }
10575 ) 12139 )
10576; 12140;
10577finally { 12141finally {
10578 restoreStackSize(stackSize); 12142 restoreStackSize(stackSize);
10579} 12143}
10580 12144
10581rule__MemberDefinition__NameAssignment_3 12145rule__Field__NameAssignment_3
10582 @init { 12146 @init {
10583 int stackSize = keepStackSize(); 12147 int stackSize = keepStackSize();
10584 } 12148 }
10585: 12149:
10586 ( 12150 (
10587 { before(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); } 12151 { before(grammarAccess.getFieldAccess().getNameIDTerminalRuleCall_3_0()); }
10588 RULE_ID 12152 RULE_ID
10589 { after(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); } 12153 { after(grammarAccess.getFieldAccess().getNameIDTerminalRuleCall_3_0()); }
10590 ) 12154 )
10591; 12155;
10592finally { 12156finally {
10593 restoreStackSize(stackSize); 12157 restoreStackSize(stackSize);
10594} 12158}
10595 12159
10596rule__MemberDefinition__OppositeAssignment_4_1 12160rule__Field__OppositeAssignment_4_1
10597 @init { 12161 @init {
10598 int stackSize = keepStackSize(); 12162 int stackSize = keepStackSize();
10599 } 12163 }
10600: 12164:
10601 ( 12165 (
10602 { before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); } 12166 { before(grammarAccess.getFieldAccess().getOppositeSymbolCrossReference_4_1_0()); }
10603 ( 12167 (
10604 { before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); } 12168 { before(grammarAccess.getFieldAccess().getOppositeSymbolQualifiedNameParserRuleCall_4_1_0_1()); }
10605 ruleQualifiedName 12169 ruleQualifiedName
10606 { after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); } 12170 { after(grammarAccess.getFieldAccess().getOppositeSymbolQualifiedNameParserRuleCall_4_1_0_1()); }
10607 ) 12171 )
10608 { after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); } 12172 { after(grammarAccess.getFieldAccess().getOppositeSymbolCrossReference_4_1_0()); }
10609 ) 12173 )
10610; 12174;
10611finally { 12175finally {
10612 restoreStackSize(stackSize); 12176 restoreStackSize(stackSize);
10613} 12177}
10614 12178
10615rule__ExactMultiplicity__MultiplicityAssignment_1 12179rule__ExactMultiplicity__ValueAssignment_1
10616 @init { 12180 @init {
10617 int stackSize = keepStackSize(); 12181 int stackSize = keepStackSize();
10618 } 12182 }
10619: 12183:
10620 ( 12184 (
10621 { before(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); } 12185 { before(grammarAccess.getExactMultiplicityAccess().getValueUpperMultiplictyParserRuleCall_1_0()); }
10622 ruleUpperMultiplicty 12186 ruleUpperMultiplicty
10623 { after(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); } 12187 { after(grammarAccess.getExactMultiplicityAccess().getValueUpperMultiplictyParserRuleCall_1_0()); }
10624 ) 12188 )
10625; 12189;
10626finally { 12190finally {
@@ -10657,230 +12221,290 @@ finally {
10657 restoreStackSize(stackSize); 12221 restoreStackSize(stackSize);
10658} 12222}
10659 12223
10660rule__ExactScopeDefinition__TypeAssignment_1 12224rule__EnumDeclaration__NameAssignment_1
12225 @init {
12226 int stackSize = keepStackSize();
12227 }
12228:
12229 (
12230 { before(grammarAccess.getEnumDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
12231 RULE_ID
12232 { after(grammarAccess.getEnumDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
12233 )
12234;
12235finally {
12236 restoreStackSize(stackSize);
12237}
12238
12239rule__EnumDeclaration__LiteralsAssignment_2_0_1_0
12240 @init {
12241 int stackSize = keepStackSize();
12242 }
12243:
12244 (
12245 { before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); }
12246 ruleEnumLiteral
12247 { after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); }
12248 )
12249;
12250finally {
12251 restoreStackSize(stackSize);
12252}
12253
12254rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1
12255 @init {
12256 int stackSize = keepStackSize();
12257 }
12258:
12259 (
12260 { before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); }
12261 ruleEnumLiteral
12262 { after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); }
12263 )
12264;
12265finally {
12266 restoreStackSize(stackSize);
12267}
12268
12269rule__EnumLiteral__NameAssignment
12270 @init {
12271 int stackSize = keepStackSize();
12272 }
12273:
12274 (
12275 { before(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0()); }
12276 RULE_ID
12277 { after(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0()); }
12278 )
12279;
12280finally {
12281 restoreStackSize(stackSize);
12282}
12283
12284rule__ExactScope__TypeAssignment_1
10661 @init { 12285 @init {
10662 int stackSize = keepStackSize(); 12286 int stackSize = keepStackSize();
10663 } 12287 }
10664: 12288:
10665 ( 12289 (
10666 { before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); } 12290 { before(grammarAccess.getExactScopeAccess().getTypeSymbolCrossReference_1_0()); }
10667 ( 12291 (
10668 { before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); } 12292 { before(grammarAccess.getExactScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
10669 ruleQualifiedName 12293 ruleQualifiedName
10670 { after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); } 12294 { after(grammarAccess.getExactScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
10671 ) 12295 )
10672 { after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); } 12296 { after(grammarAccess.getExactScopeAccess().getTypeSymbolCrossReference_1_0()); }
10673 ) 12297 )
10674; 12298;
10675finally { 12299finally {
10676 restoreStackSize(stackSize); 12300 restoreStackSize(stackSize);
10677} 12301}
10678 12302
10679rule__ExactScopeDefinition__ExactScopeAssignment_3 12303rule__ExactScope__SizeAssignment_3
10680 @init { 12304 @init {
10681 int stackSize = keepStackSize(); 12305 int stackSize = keepStackSize();
10682 } 12306 }
10683: 12307:
10684 ( 12308 (
10685 { before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); } 12309 { before(grammarAccess.getExactScopeAccess().getSizeINTTerminalRuleCall_3_0()); }
10686 RULE_INT 12310 RULE_INT
10687 { after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); } 12311 { after(grammarAccess.getExactScopeAccess().getSizeINTTerminalRuleCall_3_0()); }
10688 ) 12312 )
10689; 12313;
10690finally { 12314finally {
10691 restoreStackSize(stackSize); 12315 restoreStackSize(stackSize);
10692} 12316}
10693 12317
10694rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 12318rule__BoundedScope__LowerBoundAssignment_1_0_0_0
10695 @init { 12319 @init {
10696 int stackSize = keepStackSize(); 12320 int stackSize = keepStackSize();
10697 } 12321 }
10698: 12322:
10699 ( 12323 (
10700 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); } 12324 { before(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); }
10701 RULE_INT 12325 RULE_INT
10702 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); } 12326 { after(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); }
10703 ) 12327 )
10704; 12328;
10705finally { 12329finally {
10706 restoreStackSize(stackSize); 12330 restoreStackSize(stackSize);
10707} 12331}
10708 12332
10709rule__BoundedScopeDefinition__TypeAssignment_1_0_1 12333rule__BoundedScope__TypeAssignment_1_0_1
10710 @init { 12334 @init {
10711 int stackSize = keepStackSize(); 12335 int stackSize = keepStackSize();
10712 } 12336 }
10713: 12337:
10714 ( 12338 (
10715 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); } 12339 { before(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_0_1_0()); }
10716 ( 12340 (
10717 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); } 12341 { before(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1_0_1()); }
10718 ruleQualifiedName 12342 ruleQualifiedName
10719 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); } 12343 { after(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1_0_1()); }
10720 ) 12344 )
10721 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); } 12345 { after(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_0_1_0()); }
10722 ) 12346 )
10723; 12347;
10724finally { 12348finally {
10725 restoreStackSize(stackSize); 12349 restoreStackSize(stackSize);
10726} 12350}
10727 12351
10728rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 12352rule__BoundedScope__UpperBoundAssignment_1_0_3
10729 @init { 12353 @init {
10730 int stackSize = keepStackSize(); 12354 int stackSize = keepStackSize();
10731 } 12355 }
10732: 12356:
10733 ( 12357 (
10734 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); } 12358 { before(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); }
10735 RULE_INT 12359 RULE_INT
10736 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); } 12360 { after(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); }
10737 ) 12361 )
10738; 12362;
10739finally { 12363finally {
10740 restoreStackSize(stackSize); 12364 restoreStackSize(stackSize);
10741} 12365}
10742 12366
10743rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 12367rule__BoundedScope__UpperBoundAssignment_1_1_0
10744 @init { 12368 @init {
10745 int stackSize = keepStackSize(); 12369 int stackSize = keepStackSize();
10746 } 12370 }
10747: 12371:
10748 ( 12372 (
10749 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); } 12373 { before(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); }
10750 RULE_INT 12374 RULE_INT
10751 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); } 12375 { after(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); }
10752 ) 12376 )
10753; 12377;
10754finally { 12378finally {
10755 restoreStackSize(stackSize); 12379 restoreStackSize(stackSize);
10756} 12380}
10757 12381
10758rule__BoundedScopeDefinition__TypeAssignment_1_1_2 12382rule__BoundedScope__TypeAssignment_1_1_2
10759 @init { 12383 @init {
10760 int stackSize = keepStackSize(); 12384 int stackSize = keepStackSize();
10761 } 12385 }
10762: 12386:
10763 ( 12387 (
10764 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); } 12388 { before(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_1_2_0()); }
10765 ( 12389 (
10766 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); } 12390 { before(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_2_0_1()); }
10767 ruleQualifiedName 12391 ruleQualifiedName
10768 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); } 12392 { after(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_2_0_1()); }
10769 ) 12393 )
10770 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); } 12394 { after(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_1_2_0()); }
10771 ) 12395 )
10772; 12396;
10773finally { 12397finally {
10774 restoreStackSize(stackSize); 12398 restoreStackSize(stackSize);
10775} 12399}
10776 12400
10777rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 12401rule__BoundedScope__LowerBoundAssignment_1_1_3_1
10778 @init { 12402 @init {
10779 int stackSize = keepStackSize(); 12403 int stackSize = keepStackSize();
10780 } 12404 }
10781: 12405:
10782 ( 12406 (
10783 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); } 12407 { before(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); }
10784 RULE_INT 12408 RULE_INT
10785 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); } 12409 { after(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); }
10786 ) 12410 )
10787; 12411;
10788finally { 12412finally {
10789 restoreStackSize(stackSize); 12413 restoreStackSize(stackSize);
10790} 12414}
10791 12415
10792rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 12416rule__LowerBoundedScope__LowerBoundAssignment_1_0_0
10793 @init { 12417 @init {
10794 int stackSize = keepStackSize(); 12418 int stackSize = keepStackSize();
10795 } 12419 }
10796: 12420:
10797 ( 12421 (
10798 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); } 12422 { before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); }
10799 RULE_INT 12423 RULE_INT
10800 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); } 12424 { after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); }
10801 ) 12425 )
10802; 12426;
10803finally { 12427finally {
10804 restoreStackSize(stackSize); 12428 restoreStackSize(stackSize);
10805} 12429}
10806 12430
10807rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 12431rule__LowerBoundedScope__TypeAssignment_1_0_2
10808 @init { 12432 @init {
10809 int stackSize = keepStackSize(); 12433 int stackSize = keepStackSize();
10810 } 12434 }
10811: 12435:
10812 ( 12436 (
10813 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); } 12437 { before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_0_2_0()); }
10814 ( 12438 (
10815 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); } 12439 { before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_2_0_1()); }
10816 ruleQualifiedName 12440 ruleQualifiedName
10817 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); } 12441 { after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_2_0_1()); }
10818 ) 12442 )
10819 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); } 12443 { after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_0_2_0()); }
10820 ) 12444 )
10821; 12445;
10822finally { 12446finally {
10823 restoreStackSize(stackSize); 12447 restoreStackSize(stackSize);
10824} 12448}
10825 12449
10826rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 12450rule__LowerBoundedScope__TypeAssignment_1_1_0
10827 @init { 12451 @init {
10828 int stackSize = keepStackSize(); 12452 int stackSize = keepStackSize();
10829 } 12453 }
10830: 12454:
10831 ( 12455 (
10832 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); } 12456 { before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_1_0_0()); }
10833 ( 12457 (
10834 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); } 12458 { before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_0_0_1()); }
10835 ruleQualifiedName 12459 ruleQualifiedName
10836 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); } 12460 { after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_0_0_1()); }
10837 ) 12461 )
10838 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); } 12462 { after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_1_0_0()); }
10839 ) 12463 )
10840; 12464;
10841finally { 12465finally {
10842 restoreStackSize(stackSize); 12466 restoreStackSize(stackSize);
10843} 12467}
10844 12468
10845rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 12469rule__LowerBoundedScope__LowerBoundAssignment_1_1_2
10846 @init { 12470 @init {
10847 int stackSize = keepStackSize(); 12471 int stackSize = keepStackSize();
10848 } 12472 }
10849: 12473:
10850 ( 12474 (
10851 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); } 12475 { before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); }
10852 RULE_INT 12476 RULE_INT
10853 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); } 12477 { after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); }
10854 ) 12478 )
10855; 12479;
10856finally { 12480finally {
10857 restoreStackSize(stackSize); 12481 restoreStackSize(stackSize);
10858} 12482}
10859 12483
10860rule__ObjectiveDefinition__KindAssignment_0 12484rule__ObjectiveDeclaration__KindAssignment_0
10861 @init { 12485 @init {
10862 int stackSize = keepStackSize(); 12486 int stackSize = keepStackSize();
10863 } 12487 }
10864: 12488:
10865 ( 12489 (
10866 { before(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); } 12490 { before(grammarAccess.getObjectiveDeclarationAccess().getKindObjectiveKindEnumRuleCall_0_0()); }
10867 ruleObjectiveKind 12491 ruleObjectiveKind
10868 { after(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); } 12492 { after(grammarAccess.getObjectiveDeclarationAccess().getKindObjectiveKindEnumRuleCall_0_0()); }
10869 ) 12493 )
10870; 12494;
10871finally { 12495finally {
10872 restoreStackSize(stackSize); 12496 restoreStackSize(stackSize);
10873} 12497}
10874 12498
10875rule__ObjectiveDefinition__ObjectiveAssignment_1 12499rule__ObjectiveDeclaration__ObjectiveAssignment_1
10876 @init { 12500 @init {
10877 int stackSize = keepStackSize(); 12501 int stackSize = keepStackSize();
10878 } 12502 }
10879: 12503:
10880 ( 12504 (
10881 { before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); } 12505 { before(grammarAccess.getObjectiveDeclarationAccess().getObjectiveExpressionParserRuleCall_1_0()); }
10882 ruleExpression 12506 ruleExpression
10883 { after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); } 12507 { after(grammarAccess.getObjectiveDeclarationAccess().getObjectiveExpressionParserRuleCall_1_0()); }
10884 ) 12508 )
10885; 12509;
10886finally { 12510finally {
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-06-30 23:50:43 +0000