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.g8991
1 files changed, 8991 insertions, 0 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
new file mode 100644
index 00000000..f5a473f4
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.g
@@ -0,0 +1,8991 @@
1/*
2 * generated by Xtext 2.21.0
3 */
4parser grammar InternalSolverLanguageParser;
5
6options {
7 tokenVocab=InternalSolverLanguageLexer;
8 superClass=AbstractInternalContentAssistParser;
9}
10
11@header {
12package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal;
13import java.util.Map;
14import java.util.HashMap;
15
16import java.io.InputStream;
17import org.eclipse.xtext.*;
18import org.eclipse.xtext.parser.*;
19import org.eclipse.xtext.parser.impl.*;
20import org.eclipse.emf.ecore.util.EcoreUtil;
21import org.eclipse.emf.ecore.EObject;
22import org.eclipse.xtext.parser.antlr.XtextTokenStream;
23import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
24import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
25import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
26import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
27
28}
29@members {
30 private SolverLanguageGrammarAccess grammarAccess;
31 private final Map<String, String> tokenNameToValue = new HashMap<String, String>();
32
33 {
34 tokenNameToValue.put("ExclamationMark", "'!'");
35 tokenNameToValue.put("LeftParenthesis", "'('");
36 tokenNameToValue.put("RightParenthesis", "')'");
37 tokenNameToValue.put("Asterisk", "'*'");
38 tokenNameToValue.put("PlusSign", "'+'");
39 tokenNameToValue.put("Comma", "','");
40 tokenNameToValue.put("HyphenMinus", "'-'");
41 tokenNameToValue.put("FullStop", "'.'");
42 tokenNameToValue.put("Solidus", "'/'");
43 tokenNameToValue.put("Colon", "':'");
44 tokenNameToValue.put("Semicolon", "';'");
45 tokenNameToValue.put("LessThanSign", "'<'");
46 tokenNameToValue.put("EqualsSign", "'='");
47 tokenNameToValue.put("GreaterThanSign", "'>'");
48 tokenNameToValue.put("LeftSquareBracket", "'['");
49 tokenNameToValue.put("RightSquareBracket", "']'");
50 tokenNameToValue.put("CircumflexAccent", "'^'");
51 tokenNameToValue.put("LeftCurlyBracket", "'{'");
52 tokenNameToValue.put("VerticalLine", "'|'");
53 tokenNameToValue.put("RightCurlyBracket", "'}'");
54 tokenNameToValue.put("ExclamationMarkEqualsSign", "'!='");
55 tokenNameToValue.put("HyphenMinusGreaterThanSign", "'->'");
56 tokenNameToValue.put("FullStopFullStop", "'..'");
57 tokenNameToValue.put("ColonHyphenMinus", "':-'");
58 tokenNameToValue.put("LessThanSignEqualsSign", "'<='");
59 tokenNameToValue.put("EqualsSignEqualsSign", "'=='");
60 tokenNameToValue.put("GreaterThanSignEqualsSign", "'>='");
61 tokenNameToValue.put("EQ", "'EQ'");
62 tokenNameToValue.put("IN", "'IN'");
63 tokenNameToValue.put("If", "'if'");
64 tokenNameToValue.put("In", "'in'");
65 tokenNameToValue.put("ADD", "'ADD'");
66 tokenNameToValue.put("DIV", "'DIV'");
67 tokenNameToValue.put("MUL", "'MUL'");
68 tokenNameToValue.put("POW", "'POW'");
69 tokenNameToValue.put("SUB", "'SUB'");
70 tokenNameToValue.put("Avg", "'avg'");
71 tokenNameToValue.put("Inf", "'inf'");
72 tokenNameToValue.put("Int", "'int'");
73 tokenNameToValue.put("Max", "'max'");
74 tokenNameToValue.put("May", "'may'");
75 tokenNameToValue.put("Min", "'min'");
76 tokenNameToValue.put("Sum", "'sum'");
77 tokenNameToValue.put("LESS", "'LESS'");
78 tokenNameToValue.put("Else", "'else'");
79 tokenNameToValue.put("Must", "'must'");
80 tokenNameToValue.put("Only", "'only'");
81 tokenNameToValue.put("Prod", "'prod'");
82 tokenNameToValue.put("Real", "'real'");
83 tokenNameToValue.put("Then", "'then'");
84 tokenNameToValue.put("True", "'true'");
85 tokenNameToValue.put("Class", "'class'");
86 tokenNameToValue.put("Count", "'count'");
87 tokenNameToValue.put("Empty", "'empty'");
88 tokenNameToValue.put("Error", "'error'");
89 tokenNameToValue.put("False", "'false'");
90 tokenNameToValue.put("Scope", "'scope'");
91 tokenNameToValue.put("NOT_EQ", "'NOT_EQ'");
92 tokenNameToValue.put("Extern", "'extern'");
93 tokenNameToValue.put("GREATER", "'GREATER'");
94 tokenNameToValue.put("LESS_EQ", "'LESS_EQ'");
95 tokenNameToValue.put("Current", "'current'");
96 tokenNameToValue.put("Default", "'default'");
97 tokenNameToValue.put("Extends", "'extends'");
98 tokenNameToValue.put("Unknown", "'unknown'");
99 tokenNameToValue.put("Abstract", "'abstract'");
100 tokenNameToValue.put("Contains", "'contains'");
101 tokenNameToValue.put("Maximize", "'maximize'");
102 tokenNameToValue.put("Minimize", "'minimize'");
103 tokenNameToValue.put("Opposite", "'opposite'");
104 tokenNameToValue.put("GREATER_EQ", "'GREATER_EQ'");
105 tokenNameToValue.put("Functional", "'functional'");
106 }
107
108 public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) {
109 this.grammarAccess = grammarAccess;
110 }
111
112 @Override
113 protected Grammar getGrammar() {
114 return grammarAccess.getGrammar();
115 }
116
117 @Override
118 protected String getValueForTokenName(String tokenName) {
119 String result = tokenNameToValue.get(tokenName);
120 if (result == null)
121 result = tokenName;
122 return result;
123 }
124}
125
126// Entry rule entryRuleProblem
127entryRuleProblem
128:
129{ before(grammarAccess.getProblemRule()); }
130 ruleProblem
131{ after(grammarAccess.getProblemRule()); }
132 EOF
133;
134
135// Rule Problem
136ruleProblem
137 @init {
138 int stackSize = keepStackSize();
139 }
140 :
141 (
142 { before(grammarAccess.getProblemAccess().getStatementsAssignment()); }
143 (rule__Problem__StatementsAssignment)*
144 { after(grammarAccess.getProblemAccess().getStatementsAssignment()); }
145 )
146;
147finally {
148 restoreStackSize(stackSize);
149}
150
151// Entry rule entryRuleStatement
152entryRuleStatement
153:
154{ before(grammarAccess.getStatementRule()); }
155 ruleStatement
156{ after(grammarAccess.getStatementRule()); }
157 EOF
158;
159
160// Rule Statement
161ruleStatement
162 @init {
163 int stackSize = keepStackSize();
164 }
165 :
166 (
167 { before(grammarAccess.getStatementAccess().getGroup()); }
168 (rule__Statement__Group__0)
169 { after(grammarAccess.getStatementAccess().getGroup()); }
170 )
171;
172finally {
173 restoreStackSize(stackSize);
174}
175
176// Entry rule entryRuleAssertionOrDefinition
177entryRuleAssertionOrDefinition
178:
179{ before(grammarAccess.getAssertionOrDefinitionRule()); }
180 ruleAssertionOrDefinition
181{ after(grammarAccess.getAssertionOrDefinitionRule()); }
182 EOF
183;
184
185// Rule AssertionOrDefinition
186ruleAssertionOrDefinition
187 @init {
188 int stackSize = keepStackSize();
189 }
190 :
191 (
192 { before(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); }
193 (rule__AssertionOrDefinition__Group__0)
194 { after(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); }
195 )
196;
197finally {
198 restoreStackSize(stackSize);
199}
200
201// Entry rule entryRulePredicateDefinition
202entryRulePredicateDefinition
203:
204{ before(grammarAccess.getPredicateDefinitionRule()); }
205 rulePredicateDefinition
206{ after(grammarAccess.getPredicateDefinitionRule()); }
207 EOF
208;
209
210// Rule PredicateDefinition
211rulePredicateDefinition
212 @init {
213 int stackSize = keepStackSize();
214 }
215 :
216 (
217 { before(grammarAccess.getPredicateDefinitionAccess().getGroup()); }
218 (rule__PredicateDefinition__Group__0)
219 { after(grammarAccess.getPredicateDefinitionAccess().getGroup()); }
220 )
221;
222finally {
223 restoreStackSize(stackSize);
224}
225
226// Entry rule entryRuleUnnamedErrorPrediateDefinition
227entryRuleUnnamedErrorPrediateDefinition
228:
229{ before(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); }
230 ruleUnnamedErrorPrediateDefinition
231{ after(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); }
232 EOF
233;
234
235// Rule UnnamedErrorPrediateDefinition
236ruleUnnamedErrorPrediateDefinition
237 @init {
238 int stackSize = keepStackSize();
239 }
240 :
241 (
242 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); }
243 (rule__UnnamedErrorPrediateDefinition__Group__0)
244 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); }
245 )
246;
247finally {
248 restoreStackSize(stackSize);
249}
250
251// Entry rule entryRuleDefaultDefinition
252entryRuleDefaultDefinition
253:
254{ before(grammarAccess.getDefaultDefinitionRule()); }
255 ruleDefaultDefinition
256{ after(grammarAccess.getDefaultDefinitionRule()); }
257 EOF
258;
259
260// Rule DefaultDefinition
261ruleDefaultDefinition
262 @init {
263 int stackSize = keepStackSize();
264 }
265 :
266 (
267 { before(grammarAccess.getDefaultDefinitionAccess().getGroup()); }
268 (rule__DefaultDefinition__Group__0)
269 { after(grammarAccess.getDefaultDefinitionAccess().getGroup()); }
270 )
271;
272finally {
273 restoreStackSize(stackSize);
274}
275
276// Entry rule entryRuleExternPredicateDefinition
277entryRuleExternPredicateDefinition
278:
279{ before(grammarAccess.getExternPredicateDefinitionRule()); }
280 ruleExternPredicateDefinition
281{ after(grammarAccess.getExternPredicateDefinitionRule()); }
282 EOF
283;
284
285// Rule ExternPredicateDefinition
286ruleExternPredicateDefinition
287 @init {
288 int stackSize = keepStackSize();
289 }
290 :
291 (
292 { before(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); }
293 (rule__ExternPredicateDefinition__Group__0)
294 { after(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); }
295 )
296;
297finally {
298 restoreStackSize(stackSize);
299}
300
301// Entry rule entryRuleMetricDefinition
302entryRuleMetricDefinition
303:
304{ before(grammarAccess.getMetricDefinitionRule()); }
305 ruleMetricDefinition
306{ after(grammarAccess.getMetricDefinitionRule()); }
307 EOF
308;
309
310// Rule MetricDefinition
311ruleMetricDefinition
312 @init {
313 int stackSize = keepStackSize();
314 }
315 :
316 (
317 { before(grammarAccess.getMetricDefinitionAccess().getGroup()); }
318 (rule__MetricDefinition__Group__0)
319 { after(grammarAccess.getMetricDefinitionAccess().getGroup()); }
320 )
321;
322finally {
323 restoreStackSize(stackSize);
324}
325
326// Entry rule entryRuleExternMetricDefinition
327entryRuleExternMetricDefinition
328:
329{ before(grammarAccess.getExternMetricDefinitionRule()); }
330 ruleExternMetricDefinition
331{ after(grammarAccess.getExternMetricDefinitionRule()); }
332 EOF
333;
334
335// Rule ExternMetricDefinition
336ruleExternMetricDefinition
337 @init {
338 int stackSize = keepStackSize();
339 }
340 :
341 (
342 { before(grammarAccess.getExternMetricDefinitionAccess().getGroup()); }
343 (rule__ExternMetricDefinition__Group__0)
344 { after(grammarAccess.getExternMetricDefinitionAccess().getGroup()); }
345 )
346;
347finally {
348 restoreStackSize(stackSize);
349}
350
351// Entry rule entryRuleExpression
352entryRuleExpression
353:
354{ before(grammarAccess.getExpressionRule()); }
355 ruleExpression
356{ after(grammarAccess.getExpressionRule()); }
357 EOF
358;
359
360// Rule Expression
361ruleExpression
362 @init {
363 int stackSize = keepStackSize();
364 }
365 :
366 (
367 { before(grammarAccess.getExpressionAccess().getAlternatives()); }
368 (rule__Expression__Alternatives)
369 { after(grammarAccess.getExpressionAccess().getAlternatives()); }
370 )
371;
372finally {
373 restoreStackSize(stackSize);
374}
375
376// Entry rule entryRuleIfElse
377entryRuleIfElse
378:
379{ before(grammarAccess.getIfElseRule()); }
380 ruleIfElse
381{ after(grammarAccess.getIfElseRule()); }
382 EOF
383;
384
385// Rule IfElse
386ruleIfElse
387 @init {
388 int stackSize = keepStackSize();
389 }
390 :
391 (
392 { before(grammarAccess.getIfElseAccess().getGroup()); }
393 (rule__IfElse__Group__0)
394 { after(grammarAccess.getIfElseAccess().getGroup()); }
395 )
396;
397finally {
398 restoreStackSize(stackSize);
399}
400
401// Entry rule entryRuleDisjunctiveExpression
402entryRuleDisjunctiveExpression
403:
404{ before(grammarAccess.getDisjunctiveExpressionRule()); }
405 ruleDisjunctiveExpression
406{ after(grammarAccess.getDisjunctiveExpressionRule()); }
407 EOF
408;
409
410// Rule DisjunctiveExpression
411ruleDisjunctiveExpression
412 @init {
413 int stackSize = keepStackSize();
414 }
415 :
416 (
417 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); }
418 (rule__DisjunctiveExpression__Group__0)
419 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); }
420 )
421;
422finally {
423 restoreStackSize(stackSize);
424}
425
426// Entry rule entryRuleCase
427entryRuleCase
428:
429{ before(grammarAccess.getCaseRule()); }
430 ruleCase
431{ after(grammarAccess.getCaseRule()); }
432 EOF
433;
434
435// Rule Case
436ruleCase
437 @init {
438 int stackSize = keepStackSize();
439 }
440 :
441 (
442 { before(grammarAccess.getCaseAccess().getGroup()); }
443 (rule__Case__Group__0)
444 { after(grammarAccess.getCaseAccess().getGroup()); }
445 )
446;
447finally {
448 restoreStackSize(stackSize);
449}
450
451// Entry rule entryRuleConjunctiveExpression
452entryRuleConjunctiveExpression
453:
454{ before(grammarAccess.getConjunctiveExpressionRule()); }
455 ruleConjunctiveExpression
456{ after(grammarAccess.getConjunctiveExpressionRule()); }
457 EOF
458;
459
460// Rule ConjunctiveExpression
461ruleConjunctiveExpression
462 @init {
463 int stackSize = keepStackSize();
464 }
465 :
466 (
467 { before(grammarAccess.getConjunctiveExpressionAccess().getGroup()); }
468 (rule__ConjunctiveExpression__Group__0)
469 { after(grammarAccess.getConjunctiveExpressionAccess().getGroup()); }
470 )
471;
472finally {
473 restoreStackSize(stackSize);
474}
475
476// Entry rule entryRuleComparisonExpression
477entryRuleComparisonExpression
478:
479{ before(grammarAccess.getComparisonExpressionRule()); }
480 ruleComparisonExpression
481{ after(grammarAccess.getComparisonExpressionRule()); }
482 EOF
483;
484
485// Rule ComparisonExpression
486ruleComparisonExpression
487 @init {
488 int stackSize = keepStackSize();
489 }
490 :
491 (
492 { before(grammarAccess.getComparisonExpressionAccess().getGroup()); }
493 (rule__ComparisonExpression__Group__0)
494 { after(grammarAccess.getComparisonExpressionAccess().getGroup()); }
495 )
496;
497finally {
498 restoreStackSize(stackSize);
499}
500
501// Entry rule entryRuleAdditiveExpression
502entryRuleAdditiveExpression
503:
504{ before(grammarAccess.getAdditiveExpressionRule()); }
505 ruleAdditiveExpression
506{ after(grammarAccess.getAdditiveExpressionRule()); }
507 EOF
508;
509
510// Rule AdditiveExpression
511ruleAdditiveExpression
512 @init {
513 int stackSize = keepStackSize();
514 }
515 :
516 (
517 { before(grammarAccess.getAdditiveExpressionAccess().getGroup()); }
518 (rule__AdditiveExpression__Group__0)
519 { after(grammarAccess.getAdditiveExpressionAccess().getGroup()); }
520 )
521;
522finally {
523 restoreStackSize(stackSize);
524}
525
526// Entry rule entryRuleMultiplicativeExpression
527entryRuleMultiplicativeExpression
528:
529{ before(grammarAccess.getMultiplicativeExpressionRule()); }
530 ruleMultiplicativeExpression
531{ after(grammarAccess.getMultiplicativeExpressionRule()); }
532 EOF
533;
534
535// Rule MultiplicativeExpression
536ruleMultiplicativeExpression
537 @init {
538 int stackSize = keepStackSize();
539 }
540 :
541 (
542 { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); }
543 (rule__MultiplicativeExpression__Group__0)
544 { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); }
545 )
546;
547finally {
548 restoreStackSize(stackSize);
549}
550
551// Entry rule entryRuleExponentialExpression
552entryRuleExponentialExpression
553:
554{ before(grammarAccess.getExponentialExpressionRule()); }
555 ruleExponentialExpression
556{ after(grammarAccess.getExponentialExpressionRule()); }
557 EOF
558;
559
560// Rule ExponentialExpression
561ruleExponentialExpression
562 @init {
563 int stackSize = keepStackSize();
564 }
565 :
566 (
567 { before(grammarAccess.getExponentialExpressionAccess().getGroup()); }
568 (rule__ExponentialExpression__Group__0)
569 { after(grammarAccess.getExponentialExpressionAccess().getGroup()); }
570 )
571;
572finally {
573 restoreStackSize(stackSize);
574}
575
576// Entry rule entryRuleUnaryExpression
577entryRuleUnaryExpression
578:
579{ before(grammarAccess.getUnaryExpressionRule()); }
580 ruleUnaryExpression
581{ after(grammarAccess.getUnaryExpressionRule()); }
582 EOF
583;
584
585// Rule UnaryExpression
586ruleUnaryExpression
587 @init {
588 int stackSize = keepStackSize();
589 }
590 :
591 (
592 { before(grammarAccess.getUnaryExpressionAccess().getAlternatives()); }
593 (rule__UnaryExpression__Alternatives)
594 { after(grammarAccess.getUnaryExpressionAccess().getAlternatives()); }
595 )
596;
597finally {
598 restoreStackSize(stackSize);
599}
600
601// Entry rule entryRuleAggregationExpression
602entryRuleAggregationExpression
603:
604{ before(grammarAccess.getAggregationExpressionRule()); }
605 ruleAggregationExpression
606{ after(grammarAccess.getAggregationExpressionRule()); }
607 EOF
608;
609
610// Rule AggregationExpression
611ruleAggregationExpression
612 @init {
613 int stackSize = keepStackSize();
614 }
615 :
616 (
617 { before(grammarAccess.getAggregationExpressionAccess().getAlternatives()); }
618 (rule__AggregationExpression__Alternatives)
619 { after(grammarAccess.getAggregationExpressionAccess().getAlternatives()); }
620 )
621;
622finally {
623 restoreStackSize(stackSize);
624}
625
626// Entry rule entryRuleCount
627entryRuleCount
628:
629{ before(grammarAccess.getCountRule()); }
630 ruleCount
631{ after(grammarAccess.getCountRule()); }
632 EOF
633;
634
635// Rule Count
636ruleCount
637 @init {
638 int stackSize = keepStackSize();
639 }
640 :
641 (
642 { before(grammarAccess.getCountAccess().getGroup()); }
643 (rule__Count__Group__0)
644 { after(grammarAccess.getCountAccess().getGroup()); }
645 )
646;
647finally {
648 restoreStackSize(stackSize);
649}
650
651// Entry rule entryRuleAggregation
652entryRuleAggregation
653:
654{ before(grammarAccess.getAggregationRule()); }
655 ruleAggregation
656{ after(grammarAccess.getAggregationRule()); }
657 EOF
658;
659
660// Rule Aggregation
661ruleAggregation
662 @init {
663 int stackSize = keepStackSize();
664 }
665 :
666 (
667 { before(grammarAccess.getAggregationAccess().getGroup()); }
668 (rule__Aggregation__Group__0)
669 { after(grammarAccess.getAggregationAccess().getGroup()); }
670 )
671;
672finally {
673 restoreStackSize(stackSize);
674}
675
676// Entry rule entryRuleAtomicExpression
677entryRuleAtomicExpression
678:
679{ before(grammarAccess.getAtomicExpressionRule()); }
680 ruleAtomicExpression
681{ after(grammarAccess.getAtomicExpressionRule()); }
682 EOF
683;
684
685// Rule AtomicExpression
686ruleAtomicExpression
687 @init {
688 int stackSize = keepStackSize();
689 }
690 :
691 (
692 { before(grammarAccess.getAtomicExpressionAccess().getAlternatives()); }
693 (rule__AtomicExpression__Alternatives)
694 { after(grammarAccess.getAtomicExpressionAccess().getAlternatives()); }
695 )
696;
697finally {
698 restoreStackSize(stackSize);
699}
700
701// Entry rule entryRuleCall
702entryRuleCall
703:
704{ before(grammarAccess.getCallRule()); }
705 ruleCall
706{ after(grammarAccess.getCallRule()); }
707 EOF
708;
709
710// Rule Call
711ruleCall
712 @init {
713 int stackSize = keepStackSize();
714 }
715 :
716 (
717 { before(grammarAccess.getCallAccess().getGroup()); }
718 (rule__Call__Group__0)
719 { after(grammarAccess.getCallAccess().getGroup()); }
720 )
721;
722finally {
723 restoreStackSize(stackSize);
724}
725
726// Entry rule entryRuleArgumentList
727entryRuleArgumentList
728:
729{ before(grammarAccess.getArgumentListRule()); }
730 ruleArgumentList
731{ after(grammarAccess.getArgumentListRule()); }
732 EOF
733;
734
735// Rule ArgumentList
736ruleArgumentList
737 @init {
738 int stackSize = keepStackSize();
739 }
740 :
741 (
742 { before(grammarAccess.getArgumentListAccess().getGroup()); }
743 (rule__ArgumentList__Group__0)
744 { after(grammarAccess.getArgumentListAccess().getGroup()); }
745 )
746;
747finally {
748 restoreStackSize(stackSize);
749}
750
751// Entry rule entryRuleArgument
752entryRuleArgument
753:
754{ before(grammarAccess.getArgumentRule()); }
755 ruleArgument
756{ after(grammarAccess.getArgumentRule()); }
757 EOF
758;
759
760// Rule Argument
761ruleArgument
762 @init {
763 int stackSize = keepStackSize();
764 }
765 :
766 (
767 { before(grammarAccess.getArgumentAccess().getAlternatives()); }
768 (rule__Argument__Alternatives)
769 { after(grammarAccess.getArgumentAccess().getAlternatives()); }
770 )
771;
772finally {
773 restoreStackSize(stackSize);
774}
775
776// Entry rule entryRuleExpressionArgument
777entryRuleExpressionArgument
778:
779{ before(grammarAccess.getExpressionArgumentRule()); }
780 ruleExpressionArgument
781{ after(grammarAccess.getExpressionArgumentRule()); }
782 EOF
783;
784
785// Rule ExpressionArgument
786ruleExpressionArgument
787 @init {
788 int stackSize = keepStackSize();
789 }
790 :
791 (
792 { before(grammarAccess.getExpressionArgumentAccess().getBodyAssignment()); }
793 (rule__ExpressionArgument__BodyAssignment)
794 { after(grammarAccess.getExpressionArgumentAccess().getBodyAssignment()); }
795 )
796;
797finally {
798 restoreStackSize(stackSize);
799}
800
801// Entry rule entryRuleStarArgument
802entryRuleStarArgument
803:
804{ before(grammarAccess.getStarArgumentRule()); }
805 ruleStarArgument
806{ after(grammarAccess.getStarArgumentRule()); }
807 EOF
808;
809
810// Rule StarArgument
811ruleStarArgument
812 @init {
813 int stackSize = keepStackSize();
814 }
815 :
816 (
817 { before(grammarAccess.getStarArgumentAccess().getGroup()); }
818 (rule__StarArgument__Group__0)
819 { after(grammarAccess.getStarArgumentAccess().getGroup()); }
820 )
821;
822finally {
823 restoreStackSize(stackSize);
824}
825
826// Entry rule entryRuleTypedArgument
827entryRuleTypedArgument
828:
829{ before(grammarAccess.getTypedArgumentRule()); }
830 ruleTypedArgument
831{ after(grammarAccess.getTypedArgumentRule()); }
832 EOF
833;
834
835// Rule TypedArgument
836ruleTypedArgument
837 @init {
838 int stackSize = keepStackSize();
839 }
840 :
841 (
842 { before(grammarAccess.getTypedArgumentAccess().getGroup()); }
843 (rule__TypedArgument__Group__0)
844 { after(grammarAccess.getTypedArgumentAccess().getGroup()); }
845 )
846;
847finally {
848 restoreStackSize(stackSize);
849}
850
851// Entry rule entryRuleTypedStarArgument
852entryRuleTypedStarArgument
853:
854{ before(grammarAccess.getTypedStarArgumentRule()); }
855 ruleTypedStarArgument
856{ after(grammarAccess.getTypedStarArgumentRule()); }
857 EOF
858;
859
860// Rule TypedStarArgument
861ruleTypedStarArgument
862 @init {
863 int stackSize = keepStackSize();
864 }
865 :
866 (
867 { before(grammarAccess.getTypedStarArgumentAccess().getGroup()); }
868 (rule__TypedStarArgument__Group__0)
869 { after(grammarAccess.getTypedStarArgumentAccess().getGroup()); }
870 )
871;
872finally {
873 restoreStackSize(stackSize);
874}
875
876// Entry rule entryRuleReference
877entryRuleReference
878:
879{ before(grammarAccess.getReferenceRule()); }
880 ruleReference
881{ after(grammarAccess.getReferenceRule()); }
882 EOF
883;
884
885// Rule Reference
886ruleReference
887 @init {
888 int stackSize = keepStackSize();
889 }
890 :
891 (
892 { before(grammarAccess.getReferenceAccess().getReferredAssignment()); }
893 (rule__Reference__ReferredAssignment)
894 { after(grammarAccess.getReferenceAccess().getReferredAssignment()); }
895 )
896;
897finally {
898 restoreStackSize(stackSize);
899}
900
901// Entry rule entryRuleInterval
902entryRuleInterval
903:
904{ before(grammarAccess.getIntervalRule()); }
905 ruleInterval
906{ after(grammarAccess.getIntervalRule()); }
907 EOF
908;
909
910// Rule Interval
911ruleInterval
912 @init {
913 int stackSize = keepStackSize();
914 }
915 :
916 (
917 { before(grammarAccess.getIntervalAccess().getGroup()); }
918 (rule__Interval__Group__0)
919 { after(grammarAccess.getIntervalAccess().getGroup()); }
920 )
921;
922finally {
923 restoreStackSize(stackSize);
924}
925
926// Entry rule entryRuleLiteral
927entryRuleLiteral
928:
929{ before(grammarAccess.getLiteralRule()); }
930 ruleLiteral
931{ after(grammarAccess.getLiteralRule()); }
932 EOF
933;
934
935// Rule Literal
936ruleLiteral
937 @init {
938 int stackSize = keepStackSize();
939 }
940 :
941 (
942 { before(grammarAccess.getLiteralAccess().getAlternatives()); }
943 (rule__Literal__Alternatives)
944 { after(grammarAccess.getLiteralAccess().getAlternatives()); }
945 )
946;
947finally {
948 restoreStackSize(stackSize);
949}
950
951// Entry rule entryRuleLogicLiteral
952entryRuleLogicLiteral
953:
954{ before(grammarAccess.getLogicLiteralRule()); }
955 ruleLogicLiteral
956{ after(grammarAccess.getLogicLiteralRule()); }
957 EOF
958;
959
960// Rule LogicLiteral
961ruleLogicLiteral
962 @init {
963 int stackSize = keepStackSize();
964 }
965 :
966 (
967 { before(grammarAccess.getLogicLiteralAccess().getValueAssignment()); }
968 (rule__LogicLiteral__ValueAssignment)
969 { after(grammarAccess.getLogicLiteralAccess().getValueAssignment()); }
970 )
971;
972finally {
973 restoreStackSize(stackSize);
974}
975
976// Entry rule entryRuleNumericLiteral
977entryRuleNumericLiteral
978:
979{ before(grammarAccess.getNumericLiteralRule()); }
980 ruleNumericLiteral
981{ after(grammarAccess.getNumericLiteralRule()); }
982 EOF
983;
984
985// Rule NumericLiteral
986ruleNumericLiteral
987 @init {
988 int stackSize = keepStackSize();
989 }
990 :
991 (
992 { before(grammarAccess.getNumericLiteralAccess().getValueAssignment()); }
993 (rule__NumericLiteral__ValueAssignment)
994 { after(grammarAccess.getNumericLiteralAccess().getValueAssignment()); }
995 )
996;
997finally {
998 restoreStackSize(stackSize);
999}
1000
1001// Entry rule entryRuleInfinityLiteral
1002entryRuleInfinityLiteral
1003:
1004{ before(grammarAccess.getInfinityLiteralRule()); }
1005 ruleInfinityLiteral
1006{ after(grammarAccess.getInfinityLiteralRule()); }
1007 EOF
1008;
1009
1010// Rule InfinityLiteral
1011ruleInfinityLiteral
1012 @init {
1013 int stackSize = keepStackSize();
1014 }
1015 :
1016 (
1017 { before(grammarAccess.getInfinityLiteralAccess().getGroup()); }
1018 (rule__InfinityLiteral__Group__0)
1019 { after(grammarAccess.getInfinityLiteralAccess().getGroup()); }
1020 )
1021;
1022finally {
1023 restoreStackSize(stackSize);
1024}
1025
1026// Entry rule entryRuleEmptyIntervalLiteral
1027entryRuleEmptyIntervalLiteral
1028:
1029{ before(grammarAccess.getEmptyIntervalLiteralRule()); }
1030 ruleEmptyIntervalLiteral
1031{ after(grammarAccess.getEmptyIntervalLiteralRule()); }
1032 EOF
1033;
1034
1035// Rule EmptyIntervalLiteral
1036ruleEmptyIntervalLiteral
1037 @init {
1038 int stackSize = keepStackSize();
1039 }
1040 :
1041 (
1042 { before(grammarAccess.getEmptyIntervalLiteralAccess().getGroup()); }
1043 (rule__EmptyIntervalLiteral__Group__0)
1044 { after(grammarAccess.getEmptyIntervalLiteralAccess().getGroup()); }
1045 )
1046;
1047finally {
1048 restoreStackSize(stackSize);
1049}
1050
1051// Entry rule entryRuleStringLiteral
1052entryRuleStringLiteral
1053:
1054{ before(grammarAccess.getStringLiteralRule()); }
1055 ruleStringLiteral
1056{ after(grammarAccess.getStringLiteralRule()); }
1057 EOF
1058;
1059
1060// Rule StringLiteral
1061ruleStringLiteral
1062 @init {
1063 int stackSize = keepStackSize();
1064 }
1065 :
1066 (
1067 { before(grammarAccess.getStringLiteralAccess().getValueAssignment()); }
1068 (rule__StringLiteral__ValueAssignment)
1069 { after(grammarAccess.getStringLiteralAccess().getValueAssignment()); }
1070 )
1071;
1072finally {
1073 restoreStackSize(stackSize);
1074}
1075
1076// Entry rule entryRuleClassDefinition
1077entryRuleClassDefinition
1078:
1079{ before(grammarAccess.getClassDefinitionRule()); }
1080 ruleClassDefinition
1081{ after(grammarAccess.getClassDefinitionRule()); }
1082 EOF
1083;
1084
1085// Rule ClassDefinition
1086ruleClassDefinition
1087 @init {
1088 int stackSize = keepStackSize();
1089 }
1090 :
1091 (
1092 { before(grammarAccess.getClassDefinitionAccess().getGroup()); }
1093 (rule__ClassDefinition__Group__0)
1094 { after(grammarAccess.getClassDefinitionAccess().getGroup()); }
1095 )
1096;
1097finally {
1098 restoreStackSize(stackSize);
1099}
1100
1101// Entry rule entryRuleMemberDefinition
1102entryRuleMemberDefinition
1103:
1104{ before(grammarAccess.getMemberDefinitionRule()); }
1105 ruleMemberDefinition
1106{ after(grammarAccess.getMemberDefinitionRule()); }
1107 EOF
1108;
1109
1110// Rule MemberDefinition
1111ruleMemberDefinition
1112 @init {
1113 int stackSize = keepStackSize();
1114 }
1115 :
1116 (
1117 { before(grammarAccess.getMemberDefinitionAccess().getGroup()); }
1118 (rule__MemberDefinition__Group__0)
1119 { after(grammarAccess.getMemberDefinitionAccess().getGroup()); }
1120 )
1121;
1122finally {
1123 restoreStackSize(stackSize);
1124}
1125
1126// Entry rule entryRuleMultiplicity
1127entryRuleMultiplicity
1128:
1129{ before(grammarAccess.getMultiplicityRule()); }
1130 ruleMultiplicity
1131{ after(grammarAccess.getMultiplicityRule()); }
1132 EOF
1133;
1134
1135// Rule Multiplicity
1136ruleMultiplicity
1137 @init {
1138 int stackSize = keepStackSize();
1139 }
1140 :
1141 (
1142 { before(grammarAccess.getMultiplicityAccess().getAlternatives()); }
1143 (rule__Multiplicity__Alternatives)
1144 { after(grammarAccess.getMultiplicityAccess().getAlternatives()); }
1145 )
1146;
1147finally {
1148 restoreStackSize(stackSize);
1149}
1150
1151// Entry rule entryRuleManyMultiplicity
1152entryRuleManyMultiplicity
1153:
1154{ before(grammarAccess.getManyMultiplicityRule()); }
1155 ruleManyMultiplicity
1156{ after(grammarAccess.getManyMultiplicityRule()); }
1157 EOF
1158;
1159
1160// Rule ManyMultiplicity
1161ruleManyMultiplicity
1162 @init {
1163 int stackSize = keepStackSize();
1164 }
1165 :
1166 (
1167 { before(grammarAccess.getManyMultiplicityAccess().getGroup()); }
1168 (rule__ManyMultiplicity__Group__0)
1169 { after(grammarAccess.getManyMultiplicityAccess().getGroup()); }
1170 )
1171;
1172finally {
1173 restoreStackSize(stackSize);
1174}
1175
1176// Entry rule entryRuleExactMultiplicity
1177entryRuleExactMultiplicity
1178:
1179{ before(grammarAccess.getExactMultiplicityRule()); }
1180 ruleExactMultiplicity
1181{ after(grammarAccess.getExactMultiplicityRule()); }
1182 EOF
1183;
1184
1185// Rule ExactMultiplicity
1186ruleExactMultiplicity
1187 @init {
1188 int stackSize = keepStackSize();
1189 }
1190 :
1191 (
1192 { before(grammarAccess.getExactMultiplicityAccess().getGroup()); }
1193 (rule__ExactMultiplicity__Group__0)
1194 { after(grammarAccess.getExactMultiplicityAccess().getGroup()); }
1195 )
1196;
1197finally {
1198 restoreStackSize(stackSize);
1199}
1200
1201// Entry rule entryRuleBoundedMultiplicity
1202entryRuleBoundedMultiplicity
1203:
1204{ before(grammarAccess.getBoundedMultiplicityRule()); }
1205 ruleBoundedMultiplicity
1206{ after(grammarAccess.getBoundedMultiplicityRule()); }
1207 EOF
1208;
1209
1210// Rule BoundedMultiplicity
1211ruleBoundedMultiplicity
1212 @init {
1213 int stackSize = keepStackSize();
1214 }
1215 :
1216 (
1217 { before(grammarAccess.getBoundedMultiplicityAccess().getGroup()); }
1218 (rule__BoundedMultiplicity__Group__0)
1219 { after(grammarAccess.getBoundedMultiplicityAccess().getGroup()); }
1220 )
1221;
1222finally {
1223 restoreStackSize(stackSize);
1224}
1225
1226// Entry rule entryRuleScopeDefinition
1227entryRuleScopeDefinition
1228:
1229{ before(grammarAccess.getScopeDefinitionRule()); }
1230 ruleScopeDefinition
1231{ after(grammarAccess.getScopeDefinitionRule()); }
1232 EOF
1233;
1234
1235// Rule ScopeDefinition
1236ruleScopeDefinition
1237 @init {
1238 int stackSize = keepStackSize();
1239 }
1240 :
1241 (
1242 { before(grammarAccess.getScopeDefinitionAccess().getAlternatives()); }
1243 (rule__ScopeDefinition__Alternatives)
1244 { after(grammarAccess.getScopeDefinitionAccess().getAlternatives()); }
1245 )
1246;
1247finally {
1248 restoreStackSize(stackSize);
1249}
1250
1251// Entry rule entryRuleExactScopeDefinition
1252entryRuleExactScopeDefinition
1253:
1254{ before(grammarAccess.getExactScopeDefinitionRule()); }
1255 ruleExactScopeDefinition
1256{ after(grammarAccess.getExactScopeDefinitionRule()); }
1257 EOF
1258;
1259
1260// Rule ExactScopeDefinition
1261ruleExactScopeDefinition
1262 @init {
1263 int stackSize = keepStackSize();
1264 }
1265 :
1266 (
1267 { before(grammarAccess.getExactScopeDefinitionAccess().getGroup()); }
1268 (rule__ExactScopeDefinition__Group__0)
1269 { after(grammarAccess.getExactScopeDefinitionAccess().getGroup()); }
1270 )
1271;
1272finally {
1273 restoreStackSize(stackSize);
1274}
1275
1276// Entry rule entryRuleBoundedScopeDefinition
1277entryRuleBoundedScopeDefinition
1278:
1279{ before(grammarAccess.getBoundedScopeDefinitionRule()); }
1280 ruleBoundedScopeDefinition
1281{ after(grammarAccess.getBoundedScopeDefinitionRule()); }
1282 EOF
1283;
1284
1285// Rule BoundedScopeDefinition
1286ruleBoundedScopeDefinition
1287 @init {
1288 int stackSize = keepStackSize();
1289 }
1290 :
1291 (
1292 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); }
1293 (rule__BoundedScopeDefinition__Group__0)
1294 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); }
1295 )
1296;
1297finally {
1298 restoreStackSize(stackSize);
1299}
1300
1301// Entry rule entryRuleLowerBoundedScopeDefinition
1302entryRuleLowerBoundedScopeDefinition
1303:
1304{ before(grammarAccess.getLowerBoundedScopeDefinitionRule()); }
1305 ruleLowerBoundedScopeDefinition
1306{ after(grammarAccess.getLowerBoundedScopeDefinitionRule()); }
1307 EOF
1308;
1309
1310// Rule LowerBoundedScopeDefinition
1311ruleLowerBoundedScopeDefinition
1312 @init {
1313 int stackSize = keepStackSize();
1314 }
1315 :
1316 (
1317 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); }
1318 (rule__LowerBoundedScopeDefinition__Group__0)
1319 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); }
1320 )
1321;
1322finally {
1323 restoreStackSize(stackSize);
1324}
1325
1326// Entry rule entryRuleObjectiveDefinition
1327entryRuleObjectiveDefinition
1328:
1329{ before(grammarAccess.getObjectiveDefinitionRule()); }
1330 ruleObjectiveDefinition
1331{ after(grammarAccess.getObjectiveDefinitionRule()); }
1332 EOF
1333;
1334
1335// Rule ObjectiveDefinition
1336ruleObjectiveDefinition
1337 @init {
1338 int stackSize = keepStackSize();
1339 }
1340 :
1341 (
1342 { before(grammarAccess.getObjectiveDefinitionAccess().getGroup()); }
1343 (rule__ObjectiveDefinition__Group__0)
1344 { after(grammarAccess.getObjectiveDefinitionAccess().getGroup()); }
1345 )
1346;
1347finally {
1348 restoreStackSize(stackSize);
1349}
1350
1351// Entry rule entryRuleUpperMultiplicty
1352entryRuleUpperMultiplicty
1353:
1354{ before(grammarAccess.getUpperMultiplictyRule()); }
1355 ruleUpperMultiplicty
1356{ after(grammarAccess.getUpperMultiplictyRule()); }
1357 EOF
1358;
1359
1360// Rule UpperMultiplicty
1361ruleUpperMultiplicty
1362 @init {
1363 int stackSize = keepStackSize();
1364 }
1365 :
1366 (
1367 { before(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); }
1368 (rule__UpperMultiplicty__Alternatives)
1369 { after(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); }
1370 )
1371;
1372finally {
1373 restoreStackSize(stackSize);
1374}
1375
1376// Entry rule entryRuleReal
1377entryRuleReal
1378@init {
1379 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
1380}
1381:
1382{ before(grammarAccess.getRealRule()); }
1383 ruleReal
1384{ after(grammarAccess.getRealRule()); }
1385 EOF
1386;
1387finally {
1388 myHiddenTokenState.restore();
1389}
1390
1391// Rule Real
1392ruleReal
1393 @init {
1394 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
1395 int stackSize = keepStackSize();
1396 }
1397 :
1398 (
1399 { before(grammarAccess.getRealAccess().getGroup()); }
1400 (rule__Real__Group__0)
1401 { after(grammarAccess.getRealAccess().getGroup()); }
1402 )
1403;
1404finally {
1405 restoreStackSize(stackSize);
1406 myHiddenTokenState.restore();
1407}
1408
1409// Entry rule entryRuleQualifiedName
1410entryRuleQualifiedName
1411@init {
1412 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
1413}
1414:
1415{ before(grammarAccess.getQualifiedNameRule()); }
1416 ruleQualifiedName
1417{ after(grammarAccess.getQualifiedNameRule()); }
1418 EOF
1419;
1420finally {
1421 myHiddenTokenState.restore();
1422}
1423
1424// Rule QualifiedName
1425ruleQualifiedName
1426 @init {
1427 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
1428 int stackSize = keepStackSize();
1429 }
1430 :
1431 (
1432 { before(grammarAccess.getQualifiedNameAccess().getAlternatives()); }
1433 (rule__QualifiedName__Alternatives)
1434 { after(grammarAccess.getQualifiedNameAccess().getAlternatives()); }
1435 )
1436;
1437finally {
1438 restoreStackSize(stackSize);
1439 myHiddenTokenState.restore();
1440}
1441
1442// Rule MetricType
1443ruleMetricType
1444 @init {
1445 int stackSize = keepStackSize();
1446 }
1447:
1448 (
1449 { before(grammarAccess.getMetricTypeAccess().getAlternatives()); }
1450 (rule__MetricType__Alternatives)
1451 { after(grammarAccess.getMetricTypeAccess().getAlternatives()); }
1452 )
1453;
1454finally {
1455 restoreStackSize(stackSize);
1456}
1457
1458// Rule ComparisonOperator
1459ruleComparisonOperator
1460 @init {
1461 int stackSize = keepStackSize();
1462 }
1463:
1464 (
1465 { before(grammarAccess.getComparisonOperatorAccess().getAlternatives()); }
1466 (rule__ComparisonOperator__Alternatives)
1467 { after(grammarAccess.getComparisonOperatorAccess().getAlternatives()); }
1468 )
1469;
1470finally {
1471 restoreStackSize(stackSize);
1472}
1473
1474// Rule AdditiveBinaryOperator
1475ruleAdditiveBinaryOperator
1476 @init {
1477 int stackSize = keepStackSize();
1478 }
1479:
1480 (
1481 { before(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); }
1482 (rule__AdditiveBinaryOperator__Alternatives)
1483 { after(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); }
1484 )
1485;
1486finally {
1487 restoreStackSize(stackSize);
1488}
1489
1490// Rule MultiplicativeBinaryOperator
1491ruleMultiplicativeBinaryOperator
1492 @init {
1493 int stackSize = keepStackSize();
1494 }
1495:
1496 (
1497 { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); }
1498 (rule__MultiplicativeBinaryOperator__Alternatives)
1499 { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); }
1500 )
1501;
1502finally {
1503 restoreStackSize(stackSize);
1504}
1505
1506// Rule ExponentialOp
1507ruleExponentialOp
1508 @init {
1509 int stackSize = keepStackSize();
1510 }
1511:
1512 (
1513 { before(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); }
1514 (CircumflexAccent)
1515 { after(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); }
1516 )
1517;
1518finally {
1519 restoreStackSize(stackSize);
1520}
1521
1522// Rule UnaryOp
1523ruleUnaryOp
1524 @init {
1525 int stackSize = keepStackSize();
1526 }
1527:
1528 (
1529 { before(grammarAccess.getUnaryOpAccess().getAlternatives()); }
1530 (rule__UnaryOp__Alternatives)
1531 { after(grammarAccess.getUnaryOpAccess().getAlternatives()); }
1532 )
1533;
1534finally {
1535 restoreStackSize(stackSize);
1536}
1537
1538// Rule AggregationOp
1539ruleAggregationOp
1540 @init {
1541 int stackSize = keepStackSize();
1542 }
1543:
1544 (
1545 { before(grammarAccess.getAggregationOpAccess().getAlternatives()); }
1546 (rule__AggregationOp__Alternatives)
1547 { after(grammarAccess.getAggregationOpAccess().getAlternatives()); }
1548 )
1549;
1550finally {
1551 restoreStackSize(stackSize);
1552}
1553
1554// Rule LogicValue
1555ruleLogicValue
1556 @init {
1557 int stackSize = keepStackSize();
1558 }
1559:
1560 (
1561 { before(grammarAccess.getLogicValueAccess().getAlternatives()); }
1562 (rule__LogicValue__Alternatives)
1563 { after(grammarAccess.getLogicValueAccess().getAlternatives()); }
1564 )
1565;
1566finally {
1567 restoreStackSize(stackSize);
1568}
1569
1570// Rule ObjectiveKind
1571ruleObjectiveKind
1572 @init {
1573 int stackSize = keepStackSize();
1574 }
1575:
1576 (
1577 { before(grammarAccess.getObjectiveKindAccess().getAlternatives()); }
1578 (rule__ObjectiveKind__Alternatives)
1579 { after(grammarAccess.getObjectiveKindAccess().getAlternatives()); }
1580 )
1581;
1582finally {
1583 restoreStackSize(stackSize);
1584}
1585
1586rule__Statement__Alternatives_0
1587 @init {
1588 int stackSize = keepStackSize();
1589 }
1590:
1591 (
1592 { before(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); }
1593 ruleAssertionOrDefinition
1594 { after(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); }
1595 )
1596 |
1597 (
1598 { before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); }
1599 rulePredicateDefinition
1600 { after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); }
1601 )
1602 |
1603 (
1604 { before(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); }
1605 ruleUnnamedErrorPrediateDefinition
1606 { after(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); }
1607 )
1608 |
1609 (
1610 { before(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); }
1611 ruleDefaultDefinition
1612 { after(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); }
1613 )
1614 |
1615 (
1616 { before(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); }
1617 ruleExternPredicateDefinition
1618 { after(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); }
1619 )
1620 |
1621 (
1622 { before(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); }
1623 ruleMetricDefinition
1624 { after(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); }
1625 )
1626 |
1627 (
1628 { before(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); }
1629 ruleExternMetricDefinition
1630 { after(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); }
1631 )
1632 |
1633 (
1634 { before(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); }
1635 ruleClassDefinition
1636 { after(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); }
1637 )
1638 |
1639 (
1640 { before(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); }
1641 ruleScopeDefinition
1642 { after(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); }
1643 )
1644 |
1645 (
1646 { before(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); }
1647 ruleObjectiveDefinition
1648 { after(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); }
1649 )
1650;
1651finally {
1652 restoreStackSize(stackSize);
1653}
1654
1655rule__AssertionOrDefinition__Alternatives_1
1656 @init {
1657 int stackSize = keepStackSize();
1658 }
1659:
1660 (
1661 { before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); }
1662 (rule__AssertionOrDefinition__Group_1_0__0)
1663 { after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); }
1664 )
1665 |
1666 (
1667 { before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); }
1668 (rule__AssertionOrDefinition__Group_1_1__0)
1669 { after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); }
1670 )
1671 |
1672 (
1673 { before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); }
1674 (rule__AssertionOrDefinition__Group_1_2__0)
1675 { after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); }
1676 )
1677;
1678finally {
1679 restoreStackSize(stackSize);
1680}
1681
1682rule__PredicateDefinition__Alternatives_0
1683 @init {
1684 int stackSize = keepStackSize();
1685 }
1686:
1687 (
1688 { before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); }
1689 (rule__PredicateDefinition__Group_0_0__0)
1690 { after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); }
1691 )
1692 |
1693 (
1694 { before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); }
1695 (rule__PredicateDefinition__Group_0_1__0)
1696 { after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); }
1697 )
1698;
1699finally {
1700 restoreStackSize(stackSize);
1701}
1702
1703rule__Expression__Alternatives
1704 @init {
1705 int stackSize = keepStackSize();
1706 }
1707:
1708 (
1709 { before(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); }
1710 ruleIfElse
1711 { after(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); }
1712 )
1713 |
1714 (
1715 { before(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); }
1716 ruleDisjunctiveExpression
1717 { after(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); }
1718 )
1719;
1720finally {
1721 restoreStackSize(stackSize);
1722}
1723
1724rule__DisjunctiveExpression__Alternatives_1
1725 @init {
1726 int stackSize = keepStackSize();
1727 }
1728:
1729 (
1730 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); }
1731 (rule__DisjunctiveExpression__Group_1_0__0)
1732 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); }
1733 )
1734 |
1735 (
1736 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); }
1737 (rule__DisjunctiveExpression__Group_1_1__0)
1738 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); }
1739 )
1740;
1741finally {
1742 restoreStackSize(stackSize);
1743}
1744
1745rule__UnaryExpression__Alternatives
1746 @init {
1747 int stackSize = keepStackSize();
1748 }
1749:
1750 (
1751 { before(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); }
1752 ruleAggregationExpression
1753 { after(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); }
1754 )
1755 |
1756 (
1757 { before(grammarAccess.getUnaryExpressionAccess().getGroup_1()); }
1758 (rule__UnaryExpression__Group_1__0)
1759 { after(grammarAccess.getUnaryExpressionAccess().getGroup_1()); }
1760 )
1761;
1762finally {
1763 restoreStackSize(stackSize);
1764}
1765
1766rule__AggregationExpression__Alternatives
1767 @init {
1768 int stackSize = keepStackSize();
1769 }
1770:
1771 (
1772 { before(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); }
1773 ruleAtomicExpression
1774 { after(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); }
1775 )
1776 |
1777 (
1778 { before(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); }
1779 ruleCount
1780 { after(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); }
1781 )
1782 |
1783 (
1784 { before(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); }
1785 ruleAggregation
1786 { after(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); }
1787 )
1788;
1789finally {
1790 restoreStackSize(stackSize);
1791}
1792
1793rule__AtomicExpression__Alternatives
1794 @init {
1795 int stackSize = keepStackSize();
1796 }
1797:
1798 (
1799 { before(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); }
1800 ruleReference
1801 { after(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); }
1802 )
1803 |
1804 (
1805 { before(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); }
1806 ruleCall
1807 { after(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); }
1808 )
1809 |
1810 (
1811 { before(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); }
1812 ruleInterval
1813 { after(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); }
1814 )
1815 |
1816 (
1817 { before(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); }
1818 ruleLiteral
1819 { after(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); }
1820 )
1821 |
1822 (
1823 { before(grammarAccess.getAtomicExpressionAccess().getGroup_4()); }
1824 (rule__AtomicExpression__Group_4__0)
1825 { after(grammarAccess.getAtomicExpressionAccess().getGroup_4()); }
1826 )
1827;
1828finally {
1829 restoreStackSize(stackSize);
1830}
1831
1832rule__Call__Alternatives_1
1833 @init {
1834 int stackSize = keepStackSize();
1835 }
1836:
1837 (
1838 { before(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); }
1839 (rule__Call__TransitiveClosureAssignment_1_0)
1840 { after(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); }
1841 )
1842 |
1843 (
1844 { before(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); }
1845 (rule__Call__ReflexiveTransitiveClosureAssignment_1_1)
1846 { after(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); }
1847 )
1848;
1849finally {
1850 restoreStackSize(stackSize);
1851}
1852
1853rule__Argument__Alternatives
1854 @init {
1855 int stackSize = keepStackSize();
1856 }
1857:
1858 (
1859 { before(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); }
1860 ruleExpressionArgument
1861 { after(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); }
1862 )
1863 |
1864 (
1865 { before(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); }
1866 ruleStarArgument
1867 { after(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); }
1868 )
1869 |
1870 (
1871 { before(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); }
1872 ruleTypedArgument
1873 { after(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); }
1874 )
1875 |
1876 (
1877 { before(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); }
1878 ruleTypedStarArgument
1879 { after(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); }
1880 )
1881;
1882finally {
1883 restoreStackSize(stackSize);
1884}
1885
1886rule__Literal__Alternatives
1887 @init {
1888 int stackSize = keepStackSize();
1889 }
1890:
1891 (
1892 { before(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); }
1893 ruleLogicLiteral
1894 { after(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); }
1895 )
1896 |
1897 (
1898 { before(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); }
1899 ruleNumericLiteral
1900 { after(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); }
1901 )
1902 |
1903 (
1904 { before(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); }
1905 ruleInfinityLiteral
1906 { after(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); }
1907 )
1908 |
1909 (
1910 { before(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); }
1911 ruleEmptyIntervalLiteral
1912 { after(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); }
1913 )
1914 |
1915 (
1916 { before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); }
1917 ruleStringLiteral
1918 { after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); }
1919 )
1920;
1921finally {
1922 restoreStackSize(stackSize);
1923}
1924
1925rule__Multiplicity__Alternatives
1926 @init {
1927 int stackSize = keepStackSize();
1928 }
1929:
1930 (
1931 { before(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); }
1932 ruleManyMultiplicity
1933 { after(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); }
1934 )
1935 |
1936 (
1937 { before(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); }
1938 ruleExactMultiplicity
1939 { after(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); }
1940 )
1941 |
1942 (
1943 { before(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); }
1944 ruleBoundedMultiplicity
1945 { after(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); }
1946 )
1947;
1948finally {
1949 restoreStackSize(stackSize);
1950}
1951
1952rule__ScopeDefinition__Alternatives
1953 @init {
1954 int stackSize = keepStackSize();
1955 }
1956:
1957 (
1958 { before(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); }
1959 ruleExactScopeDefinition
1960 { after(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); }
1961 )
1962 |
1963 (
1964 { before(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); }
1965 ruleBoundedScopeDefinition
1966 { after(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); }
1967 )
1968 |
1969 (
1970 { before(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); }
1971 ruleLowerBoundedScopeDefinition
1972 { after(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); }
1973 )
1974;
1975finally {
1976 restoreStackSize(stackSize);
1977}
1978
1979rule__BoundedScopeDefinition__Alternatives_1
1980 @init {
1981 int stackSize = keepStackSize();
1982 }
1983:
1984 (
1985 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); }
1986 (rule__BoundedScopeDefinition__Group_1_0__0)
1987 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); }
1988 )
1989 |
1990 (
1991 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); }
1992 (rule__BoundedScopeDefinition__Group_1_1__0)
1993 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); }
1994 )
1995;
1996finally {
1997 restoreStackSize(stackSize);
1998}
1999
2000rule__LowerBoundedScopeDefinition__Alternatives_1
2001 @init {
2002 int stackSize = keepStackSize();
2003 }
2004:
2005 (
2006 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); }
2007 (rule__LowerBoundedScopeDefinition__Group_1_0__0)
2008 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); }
2009 )
2010 |
2011 (
2012 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_1()); }
2013 (rule__LowerBoundedScopeDefinition__Group_1_1__0)
2014 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_1()); }
2015 )
2016;
2017finally {
2018 restoreStackSize(stackSize);
2019}
2020
2021rule__UpperMultiplicty__Alternatives
2022 @init {
2023 int stackSize = keepStackSize();
2024 }
2025:
2026 (
2027 { before(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); }
2028 RULE_INT
2029 { after(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); }
2030 )
2031 |
2032 (
2033 { before(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); }
2034 Asterisk
2035 { after(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); }
2036 )
2037;
2038finally {
2039 restoreStackSize(stackSize);
2040}
2041
2042rule__QualifiedName__Alternatives
2043 @init {
2044 int stackSize = keepStackSize();
2045 }
2046:
2047 (
2048 { before(grammarAccess.getQualifiedNameAccess().getGroup_0()); }
2049 (rule__QualifiedName__Group_0__0)
2050 { after(grammarAccess.getQualifiedNameAccess().getGroup_0()); }
2051 )
2052 |
2053 (
2054 { before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); }
2055 RULE_QUOTED_ID
2056 { after(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); }
2057 )
2058;
2059finally {
2060 restoreStackSize(stackSize);
2061}
2062
2063rule__MetricType__Alternatives
2064 @init {
2065 int stackSize = keepStackSize();
2066 }
2067:
2068 (
2069 { before(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); }
2070 (Int)
2071 { after(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); }
2072 )
2073 |
2074 (
2075 { before(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); }
2076 (Real)
2077 { after(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); }
2078 )
2079;
2080finally {
2081 restoreStackSize(stackSize);
2082}
2083
2084rule__ComparisonOperator__Alternatives
2085 @init {
2086 int stackSize = keepStackSize();
2087 }
2088:
2089 (
2090 { before(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); }
2091 (EqualsSignEqualsSign)
2092 { after(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); }
2093 )
2094 |
2095 (
2096 { before(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); }
2097 (ExclamationMarkEqualsSign)
2098 { after(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); }
2099 )
2100 |
2101 (
2102 { before(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); }
2103 (LessThanSign)
2104 { after(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); }
2105 )
2106 |
2107 (
2108 { before(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); }
2109 (LessThanSignEqualsSign)
2110 { after(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); }
2111 )
2112 |
2113 (
2114 { before(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); }
2115 (GreaterThanSign)
2116 { after(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); }
2117 )
2118 |
2119 (
2120 { before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); }
2121 (GreaterThanSignEqualsSign)
2122 { after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); }
2123 )
2124 |
2125 (
2126 { before(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); }
2127 (In)
2128 { after(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); }
2129 )
2130;
2131finally {
2132 restoreStackSize(stackSize);
2133}
2134
2135rule__AdditiveBinaryOperator__Alternatives
2136 @init {
2137 int stackSize = keepStackSize();
2138 }
2139:
2140 (
2141 { before(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); }
2142 (PlusSign)
2143 { after(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); }
2144 )
2145 |
2146 (
2147 { before(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); }
2148 (HyphenMinus)
2149 { after(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); }
2150 )
2151;
2152finally {
2153 restoreStackSize(stackSize);
2154}
2155
2156rule__MultiplicativeBinaryOperator__Alternatives
2157 @init {
2158 int stackSize = keepStackSize();
2159 }
2160:
2161 (
2162 { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); }
2163 (Asterisk)
2164 { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); }
2165 )
2166 |
2167 (
2168 { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); }
2169 (Solidus)
2170 { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); }
2171 )
2172;
2173finally {
2174 restoreStackSize(stackSize);
2175}
2176
2177rule__UnaryOp__Alternatives
2178 @init {
2179 int stackSize = keepStackSize();
2180 }
2181:
2182 (
2183 { before(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); }
2184 (ExclamationMark)
2185 { after(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); }
2186 )
2187 |
2188 (
2189 { before(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); }
2190 (PlusSign)
2191 { after(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); }
2192 )
2193 |
2194 (
2195 { before(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); }
2196 (HyphenMinus)
2197 { after(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); }
2198 )
2199 |
2200 (
2201 { before(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); }
2202 (May)
2203 { after(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); }
2204 )
2205 |
2206 (
2207 { before(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); }
2208 (Must)
2209 { after(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); }
2210 )
2211 |
2212 (
2213 { before(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); }
2214 (Current)
2215 { after(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); }
2216 )
2217;
2218finally {
2219 restoreStackSize(stackSize);
2220}
2221
2222rule__AggregationOp__Alternatives
2223 @init {
2224 int stackSize = keepStackSize();
2225 }
2226:
2227 (
2228 { before(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); }
2229 (Only)
2230 { after(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); }
2231 )
2232 |
2233 (
2234 { before(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); }
2235 (Sum)
2236 { after(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); }
2237 )
2238 |
2239 (
2240 { before(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); }
2241 (Prod)
2242 { after(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); }
2243 )
2244 |
2245 (
2246 { before(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); }
2247 (Avg)
2248 { after(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); }
2249 )
2250 |
2251 (
2252 { before(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); }
2253 (Min)
2254 { after(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); }
2255 )
2256 |
2257 (
2258 { before(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); }
2259 (Max)
2260 { after(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); }
2261 )
2262;
2263finally {
2264 restoreStackSize(stackSize);
2265}
2266
2267rule__LogicValue__Alternatives
2268 @init {
2269 int stackSize = keepStackSize();
2270 }
2271:
2272 (
2273 { before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); }
2274 (True)
2275 { after(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); }
2276 )
2277 |
2278 (
2279 { before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); }
2280 (False)
2281 { after(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); }
2282 )
2283 |
2284 (
2285 { before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); }
2286 (Unknown)
2287 { after(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); }
2288 )
2289 |
2290 (
2291 { before(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); }
2292 (Error)
2293 { after(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); }
2294 )
2295;
2296finally {
2297 restoreStackSize(stackSize);
2298}
2299
2300rule__ObjectiveKind__Alternatives
2301 @init {
2302 int stackSize = keepStackSize();
2303 }
2304:
2305 (
2306 { before(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); }
2307 (Minimize)
2308 { after(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); }
2309 )
2310 |
2311 (
2312 { before(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); }
2313 (Maximize)
2314 { after(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); }
2315 )
2316;
2317finally {
2318 restoreStackSize(stackSize);
2319}
2320
2321rule__Statement__Group__0
2322 @init {
2323 int stackSize = keepStackSize();
2324 }
2325:
2326 rule__Statement__Group__0__Impl
2327 rule__Statement__Group__1
2328;
2329finally {
2330 restoreStackSize(stackSize);
2331}
2332
2333rule__Statement__Group__0__Impl
2334 @init {
2335 int stackSize = keepStackSize();
2336 }
2337:
2338(
2339 { before(grammarAccess.getStatementAccess().getAlternatives_0()); }
2340 (rule__Statement__Alternatives_0)
2341 { after(grammarAccess.getStatementAccess().getAlternatives_0()); }
2342)
2343;
2344finally {
2345 restoreStackSize(stackSize);
2346}
2347
2348rule__Statement__Group__1
2349 @init {
2350 int stackSize = keepStackSize();
2351 }
2352:
2353 rule__Statement__Group__1__Impl
2354;
2355finally {
2356 restoreStackSize(stackSize);
2357}
2358
2359rule__Statement__Group__1__Impl
2360 @init {
2361 int stackSize = keepStackSize();
2362 }
2363:
2364(
2365 { before(grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); }
2366 RULE_FULL_STOP
2367 { after(grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); }
2368)
2369;
2370finally {
2371 restoreStackSize(stackSize);
2372}
2373
2374
2375rule__AssertionOrDefinition__Group__0
2376 @init {
2377 int stackSize = keepStackSize();
2378 }
2379:
2380 rule__AssertionOrDefinition__Group__0__Impl
2381 rule__AssertionOrDefinition__Group__1
2382;
2383finally {
2384 restoreStackSize(stackSize);
2385}
2386
2387rule__AssertionOrDefinition__Group__0__Impl
2388 @init {
2389 int stackSize = keepStackSize();
2390 }
2391:
2392(
2393 { before(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); }
2394 ruleExpression
2395 { after(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); }
2396)
2397;
2398finally {
2399 restoreStackSize(stackSize);
2400}
2401
2402rule__AssertionOrDefinition__Group__1
2403 @init {
2404 int stackSize = keepStackSize();
2405 }
2406:
2407 rule__AssertionOrDefinition__Group__1__Impl
2408;
2409finally {
2410 restoreStackSize(stackSize);
2411}
2412
2413rule__AssertionOrDefinition__Group__1__Impl
2414 @init {
2415 int stackSize = keepStackSize();
2416 }
2417:
2418(
2419 { before(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); }
2420 (rule__AssertionOrDefinition__Alternatives_1)
2421 { after(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); }
2422)
2423;
2424finally {
2425 restoreStackSize(stackSize);
2426}
2427
2428
2429rule__AssertionOrDefinition__Group_1_0__0
2430 @init {
2431 int stackSize = keepStackSize();
2432 }
2433:
2434 rule__AssertionOrDefinition__Group_1_0__0__Impl
2435 rule__AssertionOrDefinition__Group_1_0__1
2436;
2437finally {
2438 restoreStackSize(stackSize);
2439}
2440
2441rule__AssertionOrDefinition__Group_1_0__0__Impl
2442 @init {
2443 int stackSize = keepStackSize();
2444 }
2445:
2446(
2447 { before(grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0()); }
2448 ()
2449 { after(grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0()); }
2450)
2451;
2452finally {
2453 restoreStackSize(stackSize);
2454}
2455
2456rule__AssertionOrDefinition__Group_1_0__1
2457 @init {
2458 int stackSize = keepStackSize();
2459 }
2460:
2461 rule__AssertionOrDefinition__Group_1_0__1__Impl
2462;
2463finally {
2464 restoreStackSize(stackSize);
2465}
2466
2467rule__AssertionOrDefinition__Group_1_0__1__Impl
2468 @init {
2469 int stackSize = keepStackSize();
2470 }
2471:
2472(
2473 { before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); }
2474 (rule__AssertionOrDefinition__Group_1_0_1__0)?
2475 { after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); }
2476)
2477;
2478finally {
2479 restoreStackSize(stackSize);
2480}
2481
2482
2483rule__AssertionOrDefinition__Group_1_0_1__0
2484 @init {
2485 int stackSize = keepStackSize();
2486 }
2487:
2488 rule__AssertionOrDefinition__Group_1_0_1__0__Impl
2489 rule__AssertionOrDefinition__Group_1_0_1__1
2490;
2491finally {
2492 restoreStackSize(stackSize);
2493}
2494
2495rule__AssertionOrDefinition__Group_1_0_1__0__Impl
2496 @init {
2497 int stackSize = keepStackSize();
2498 }
2499:
2500(
2501 { before(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); }
2502 Colon
2503 { after(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); }
2504)
2505;
2506finally {
2507 restoreStackSize(stackSize);
2508}
2509
2510rule__AssertionOrDefinition__Group_1_0_1__1
2511 @init {
2512 int stackSize = keepStackSize();
2513 }
2514:
2515 rule__AssertionOrDefinition__Group_1_0_1__1__Impl
2516;
2517finally {
2518 restoreStackSize(stackSize);
2519}
2520
2521rule__AssertionOrDefinition__Group_1_0_1__1__Impl
2522 @init {
2523 int stackSize = keepStackSize();
2524 }
2525:
2526(
2527 { before(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); }
2528 (rule__AssertionOrDefinition__RangeAssignment_1_0_1_1)
2529 { after(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); }
2530)
2531;
2532finally {
2533 restoreStackSize(stackSize);
2534}
2535
2536
2537rule__AssertionOrDefinition__Group_1_1__0
2538 @init {
2539 int stackSize = keepStackSize();
2540 }
2541:
2542 rule__AssertionOrDefinition__Group_1_1__0__Impl
2543 rule__AssertionOrDefinition__Group_1_1__1
2544;
2545finally {
2546 restoreStackSize(stackSize);
2547}
2548
2549rule__AssertionOrDefinition__Group_1_1__0__Impl
2550 @init {
2551 int stackSize = keepStackSize();
2552 }
2553:
2554(
2555 { before(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); }
2556 ()
2557 { after(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); }
2558)
2559;
2560finally {
2561 restoreStackSize(stackSize);
2562}
2563
2564rule__AssertionOrDefinition__Group_1_1__1
2565 @init {
2566 int stackSize = keepStackSize();
2567 }
2568:
2569 rule__AssertionOrDefinition__Group_1_1__1__Impl
2570 rule__AssertionOrDefinition__Group_1_1__2
2571;
2572finally {
2573 restoreStackSize(stackSize);
2574}
2575
2576rule__AssertionOrDefinition__Group_1_1__1__Impl
2577 @init {
2578 int stackSize = keepStackSize();
2579 }
2580:
2581(
2582 { before(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); }
2583 ColonHyphenMinus
2584 { after(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); }
2585)
2586;
2587finally {
2588 restoreStackSize(stackSize);
2589}
2590
2591rule__AssertionOrDefinition__Group_1_1__2
2592 @init {
2593 int stackSize = keepStackSize();
2594 }
2595:
2596 rule__AssertionOrDefinition__Group_1_1__2__Impl
2597;
2598finally {
2599 restoreStackSize(stackSize);
2600}
2601
2602rule__AssertionOrDefinition__Group_1_1__2__Impl
2603 @init {
2604 int stackSize = keepStackSize();
2605 }
2606:
2607(
2608 { before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); }
2609 (rule__AssertionOrDefinition__BodyAssignment_1_1_2)
2610 { after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); }
2611)
2612;
2613finally {
2614 restoreStackSize(stackSize);
2615}
2616
2617
2618rule__AssertionOrDefinition__Group_1_2__0
2619 @init {
2620 int stackSize = keepStackSize();
2621 }
2622:
2623 rule__AssertionOrDefinition__Group_1_2__0__Impl
2624 rule__AssertionOrDefinition__Group_1_2__1
2625;
2626finally {
2627 restoreStackSize(stackSize);
2628}
2629
2630rule__AssertionOrDefinition__Group_1_2__0__Impl
2631 @init {
2632 int stackSize = keepStackSize();
2633 }
2634:
2635(
2636 { before(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0()); }
2637 ()
2638 { after(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0()); }
2639)
2640;
2641finally {
2642 restoreStackSize(stackSize);
2643}
2644
2645rule__AssertionOrDefinition__Group_1_2__1
2646 @init {
2647 int stackSize = keepStackSize();
2648 }
2649:
2650 rule__AssertionOrDefinition__Group_1_2__1__Impl
2651 rule__AssertionOrDefinition__Group_1_2__2
2652;
2653finally {
2654 restoreStackSize(stackSize);
2655}
2656
2657rule__AssertionOrDefinition__Group_1_2__1__Impl
2658 @init {
2659 int stackSize = keepStackSize();
2660 }
2661:
2662(
2663 { before(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); }
2664 EqualsSign
2665 { after(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); }
2666)
2667;
2668finally {
2669 restoreStackSize(stackSize);
2670}
2671
2672rule__AssertionOrDefinition__Group_1_2__2
2673 @init {
2674 int stackSize = keepStackSize();
2675 }
2676:
2677 rule__AssertionOrDefinition__Group_1_2__2__Impl
2678;
2679finally {
2680 restoreStackSize(stackSize);
2681}
2682
2683rule__AssertionOrDefinition__Group_1_2__2__Impl
2684 @init {
2685 int stackSize = keepStackSize();
2686 }
2687:
2688(
2689 { before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); }
2690 (rule__AssertionOrDefinition__BodyAssignment_1_2_2)
2691 { after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); }
2692)
2693;
2694finally {
2695 restoreStackSize(stackSize);
2696}
2697
2698
2699rule__PredicateDefinition__Group__0
2700 @init {
2701 int stackSize = keepStackSize();
2702 }
2703:
2704 rule__PredicateDefinition__Group__0__Impl
2705 rule__PredicateDefinition__Group__1
2706;
2707finally {
2708 restoreStackSize(stackSize);
2709}
2710
2711rule__PredicateDefinition__Group__0__Impl
2712 @init {
2713 int stackSize = keepStackSize();
2714 }
2715:
2716(
2717 { before(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); }
2718 (rule__PredicateDefinition__Alternatives_0)
2719 { after(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); }
2720)
2721;
2722finally {
2723 restoreStackSize(stackSize);
2724}
2725
2726rule__PredicateDefinition__Group__1
2727 @init {
2728 int stackSize = keepStackSize();
2729 }
2730:
2731 rule__PredicateDefinition__Group__1__Impl
2732 rule__PredicateDefinition__Group__2
2733;
2734finally {
2735 restoreStackSize(stackSize);
2736}
2737
2738rule__PredicateDefinition__Group__1__Impl
2739 @init {
2740 int stackSize = keepStackSize();
2741 }
2742:
2743(
2744 { before(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); }
2745 (rule__PredicateDefinition__HeadAssignment_1)
2746 { after(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); }
2747)
2748;
2749finally {
2750 restoreStackSize(stackSize);
2751}
2752
2753rule__PredicateDefinition__Group__2
2754 @init {
2755 int stackSize = keepStackSize();
2756 }
2757:
2758 rule__PredicateDefinition__Group__2__Impl
2759 rule__PredicateDefinition__Group__3
2760;
2761finally {
2762 restoreStackSize(stackSize);
2763}
2764
2765rule__PredicateDefinition__Group__2__Impl
2766 @init {
2767 int stackSize = keepStackSize();
2768 }
2769:
2770(
2771 { before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); }
2772 ColonHyphenMinus
2773 { after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); }
2774)
2775;
2776finally {
2777 restoreStackSize(stackSize);
2778}
2779
2780rule__PredicateDefinition__Group__3
2781 @init {
2782 int stackSize = keepStackSize();
2783 }
2784:
2785 rule__PredicateDefinition__Group__3__Impl
2786;
2787finally {
2788 restoreStackSize(stackSize);
2789}
2790
2791rule__PredicateDefinition__Group__3__Impl
2792 @init {
2793 int stackSize = keepStackSize();
2794 }
2795:
2796(
2797 { before(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); }
2798 (rule__PredicateDefinition__BodyAssignment_3)
2799 { after(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); }
2800)
2801;
2802finally {
2803 restoreStackSize(stackSize);
2804}
2805
2806
2807rule__PredicateDefinition__Group_0_0__0
2808 @init {
2809 int stackSize = keepStackSize();
2810 }
2811:
2812 rule__PredicateDefinition__Group_0_0__0__Impl
2813 rule__PredicateDefinition__Group_0_0__1
2814;
2815finally {
2816 restoreStackSize(stackSize);
2817}
2818
2819rule__PredicateDefinition__Group_0_0__0__Impl
2820 @init {
2821 int stackSize = keepStackSize();
2822 }
2823:
2824(
2825 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); }
2826 (rule__PredicateDefinition__FunctionalAssignment_0_0_0)
2827 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); }
2828)
2829;
2830finally {
2831 restoreStackSize(stackSize);
2832}
2833
2834rule__PredicateDefinition__Group_0_0__1
2835 @init {
2836 int stackSize = keepStackSize();
2837 }
2838:
2839 rule__PredicateDefinition__Group_0_0__1__Impl
2840;
2841finally {
2842 restoreStackSize(stackSize);
2843}
2844
2845rule__PredicateDefinition__Group_0_0__1__Impl
2846 @init {
2847 int stackSize = keepStackSize();
2848 }
2849:
2850(
2851 { before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); }
2852 (rule__PredicateDefinition__ErrorAssignment_0_0_1)?
2853 { after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); }
2854)
2855;
2856finally {
2857 restoreStackSize(stackSize);
2858}
2859
2860
2861rule__PredicateDefinition__Group_0_1__0
2862 @init {
2863 int stackSize = keepStackSize();
2864 }
2865:
2866 rule__PredicateDefinition__Group_0_1__0__Impl
2867 rule__PredicateDefinition__Group_0_1__1
2868;
2869finally {
2870 restoreStackSize(stackSize);
2871}
2872
2873rule__PredicateDefinition__Group_0_1__0__Impl
2874 @init {
2875 int stackSize = keepStackSize();
2876 }
2877:
2878(
2879 { before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); }
2880 (rule__PredicateDefinition__ErrorAssignment_0_1_0)
2881 { after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); }
2882)
2883;
2884finally {
2885 restoreStackSize(stackSize);
2886}
2887
2888rule__PredicateDefinition__Group_0_1__1
2889 @init {
2890 int stackSize = keepStackSize();
2891 }
2892:
2893 rule__PredicateDefinition__Group_0_1__1__Impl
2894;
2895finally {
2896 restoreStackSize(stackSize);
2897}
2898
2899rule__PredicateDefinition__Group_0_1__1__Impl
2900 @init {
2901 int stackSize = keepStackSize();
2902 }
2903:
2904(
2905 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); }
2906 (rule__PredicateDefinition__FunctionalAssignment_0_1_1)?
2907 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); }
2908)
2909;
2910finally {
2911 restoreStackSize(stackSize);
2912}
2913
2914
2915rule__UnnamedErrorPrediateDefinition__Group__0
2916 @init {
2917 int stackSize = keepStackSize();
2918 }
2919:
2920 rule__UnnamedErrorPrediateDefinition__Group__0__Impl
2921 rule__UnnamedErrorPrediateDefinition__Group__1
2922;
2923finally {
2924 restoreStackSize(stackSize);
2925}
2926
2927rule__UnnamedErrorPrediateDefinition__Group__0__Impl
2928 @init {
2929 int stackSize = keepStackSize();
2930 }
2931:
2932(
2933 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); }
2934 Error
2935 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); }
2936)
2937;
2938finally {
2939 restoreStackSize(stackSize);
2940}
2941
2942rule__UnnamedErrorPrediateDefinition__Group__1
2943 @init {
2944 int stackSize = keepStackSize();
2945 }
2946:
2947 rule__UnnamedErrorPrediateDefinition__Group__1__Impl
2948 rule__UnnamedErrorPrediateDefinition__Group__2
2949;
2950finally {
2951 restoreStackSize(stackSize);
2952}
2953
2954rule__UnnamedErrorPrediateDefinition__Group__1__Impl
2955 @init {
2956 int stackSize = keepStackSize();
2957 }
2958:
2959(
2960 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); }
2961 (rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1)
2962 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); }
2963)
2964;
2965finally {
2966 restoreStackSize(stackSize);
2967}
2968
2969rule__UnnamedErrorPrediateDefinition__Group__2
2970 @init {
2971 int stackSize = keepStackSize();
2972 }
2973:
2974 rule__UnnamedErrorPrediateDefinition__Group__2__Impl
2975 rule__UnnamedErrorPrediateDefinition__Group__3
2976;
2977finally {
2978 restoreStackSize(stackSize);
2979}
2980
2981rule__UnnamedErrorPrediateDefinition__Group__2__Impl
2982 @init {
2983 int stackSize = keepStackSize();
2984 }
2985:
2986(
2987 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); }
2988 ColonHyphenMinus
2989 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); }
2990)
2991;
2992finally {
2993 restoreStackSize(stackSize);
2994}
2995
2996rule__UnnamedErrorPrediateDefinition__Group__3
2997 @init {
2998 int stackSize = keepStackSize();
2999 }
3000:
3001 rule__UnnamedErrorPrediateDefinition__Group__3__Impl
3002;
3003finally {
3004 restoreStackSize(stackSize);
3005}
3006
3007rule__UnnamedErrorPrediateDefinition__Group__3__Impl
3008 @init {
3009 int stackSize = keepStackSize();
3010 }
3011:
3012(
3013 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); }
3014 (rule__UnnamedErrorPrediateDefinition__BodyAssignment_3)
3015 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); }
3016)
3017;
3018finally {
3019 restoreStackSize(stackSize);
3020}
3021
3022
3023rule__DefaultDefinition__Group__0
3024 @init {
3025 int stackSize = keepStackSize();
3026 }
3027:
3028 rule__DefaultDefinition__Group__0__Impl
3029 rule__DefaultDefinition__Group__1
3030;
3031finally {
3032 restoreStackSize(stackSize);
3033}
3034
3035rule__DefaultDefinition__Group__0__Impl
3036 @init {
3037 int stackSize = keepStackSize();
3038 }
3039:
3040(
3041 { before(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); }
3042 Default
3043 { after(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); }
3044)
3045;
3046finally {
3047 restoreStackSize(stackSize);
3048}
3049
3050rule__DefaultDefinition__Group__1
3051 @init {
3052 int stackSize = keepStackSize();
3053 }
3054:
3055 rule__DefaultDefinition__Group__1__Impl
3056 rule__DefaultDefinition__Group__2
3057;
3058finally {
3059 restoreStackSize(stackSize);
3060}
3061
3062rule__DefaultDefinition__Group__1__Impl
3063 @init {
3064 int stackSize = keepStackSize();
3065 }
3066:
3067(
3068 { before(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); }
3069 (rule__DefaultDefinition__HeadAssignment_1)
3070 { after(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); }
3071)
3072;
3073finally {
3074 restoreStackSize(stackSize);
3075}
3076
3077rule__DefaultDefinition__Group__2
3078 @init {
3079 int stackSize = keepStackSize();
3080 }
3081:
3082 rule__DefaultDefinition__Group__2__Impl
3083 rule__DefaultDefinition__Group__3
3084;
3085finally {
3086 restoreStackSize(stackSize);
3087}
3088
3089rule__DefaultDefinition__Group__2__Impl
3090 @init {
3091 int stackSize = keepStackSize();
3092 }
3093:
3094(
3095 { before(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); }
3096 Colon
3097 { after(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); }
3098)
3099;
3100finally {
3101 restoreStackSize(stackSize);
3102}
3103
3104rule__DefaultDefinition__Group__3
3105 @init {
3106 int stackSize = keepStackSize();
3107 }
3108:
3109 rule__DefaultDefinition__Group__3__Impl
3110;
3111finally {
3112 restoreStackSize(stackSize);
3113}
3114
3115rule__DefaultDefinition__Group__3__Impl
3116 @init {
3117 int stackSize = keepStackSize();
3118 }
3119:
3120(
3121 { before(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); }
3122 (rule__DefaultDefinition__RangeAssignment_3)
3123 { after(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); }
3124)
3125;
3126finally {
3127 restoreStackSize(stackSize);
3128}
3129
3130
3131rule__ExternPredicateDefinition__Group__0
3132 @init {
3133 int stackSize = keepStackSize();
3134 }
3135:
3136 rule__ExternPredicateDefinition__Group__0__Impl
3137 rule__ExternPredicateDefinition__Group__1
3138;
3139finally {
3140 restoreStackSize(stackSize);
3141}
3142
3143rule__ExternPredicateDefinition__Group__0__Impl
3144 @init {
3145 int stackSize = keepStackSize();
3146 }
3147:
3148(
3149 { before(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); }
3150 Extern
3151 { after(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); }
3152)
3153;
3154finally {
3155 restoreStackSize(stackSize);
3156}
3157
3158rule__ExternPredicateDefinition__Group__1
3159 @init {
3160 int stackSize = keepStackSize();
3161 }
3162:
3163 rule__ExternPredicateDefinition__Group__1__Impl
3164;
3165finally {
3166 restoreStackSize(stackSize);
3167}
3168
3169rule__ExternPredicateDefinition__Group__1__Impl
3170 @init {
3171 int stackSize = keepStackSize();
3172 }
3173:
3174(
3175 { before(grammarAccess.getExternPredicateDefinitionAccess().getHeadAssignment_1()); }
3176 (rule__ExternPredicateDefinition__HeadAssignment_1)
3177 { after(grammarAccess.getExternPredicateDefinitionAccess().getHeadAssignment_1()); }
3178)
3179;
3180finally {
3181 restoreStackSize(stackSize);
3182}
3183
3184
3185rule__MetricDefinition__Group__0
3186 @init {
3187 int stackSize = keepStackSize();
3188 }
3189:
3190 rule__MetricDefinition__Group__0__Impl
3191 rule__MetricDefinition__Group__1
3192;
3193finally {
3194 restoreStackSize(stackSize);
3195}
3196
3197rule__MetricDefinition__Group__0__Impl
3198 @init {
3199 int stackSize = keepStackSize();
3200 }
3201:
3202(
3203 { before(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); }
3204 (rule__MetricDefinition__TypeAssignment_0)
3205 { after(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); }
3206)
3207;
3208finally {
3209 restoreStackSize(stackSize);
3210}
3211
3212rule__MetricDefinition__Group__1
3213 @init {
3214 int stackSize = keepStackSize();
3215 }
3216:
3217 rule__MetricDefinition__Group__1__Impl
3218 rule__MetricDefinition__Group__2
3219;
3220finally {
3221 restoreStackSize(stackSize);
3222}
3223
3224rule__MetricDefinition__Group__1__Impl
3225 @init {
3226 int stackSize = keepStackSize();
3227 }
3228:
3229(
3230 { before(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); }
3231 (rule__MetricDefinition__HeadAssignment_1)
3232 { after(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); }
3233)
3234;
3235finally {
3236 restoreStackSize(stackSize);
3237}
3238
3239rule__MetricDefinition__Group__2
3240 @init {
3241 int stackSize = keepStackSize();
3242 }
3243:
3244 rule__MetricDefinition__Group__2__Impl
3245 rule__MetricDefinition__Group__3
3246;
3247finally {
3248 restoreStackSize(stackSize);
3249}
3250
3251rule__MetricDefinition__Group__2__Impl
3252 @init {
3253 int stackSize = keepStackSize();
3254 }
3255:
3256(
3257 { before(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); }
3258 EqualsSign
3259 { after(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); }
3260)
3261;
3262finally {
3263 restoreStackSize(stackSize);
3264}
3265
3266rule__MetricDefinition__Group__3
3267 @init {
3268 int stackSize = keepStackSize();
3269 }
3270:
3271 rule__MetricDefinition__Group__3__Impl
3272;
3273finally {
3274 restoreStackSize(stackSize);
3275}
3276
3277rule__MetricDefinition__Group__3__Impl
3278 @init {
3279 int stackSize = keepStackSize();
3280 }
3281:
3282(
3283 { before(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); }
3284 (rule__MetricDefinition__BodyAssignment_3)
3285 { after(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); }
3286)
3287;
3288finally {
3289 restoreStackSize(stackSize);
3290}
3291
3292
3293rule__ExternMetricDefinition__Group__0
3294 @init {
3295 int stackSize = keepStackSize();
3296 }
3297:
3298 rule__ExternMetricDefinition__Group__0__Impl
3299 rule__ExternMetricDefinition__Group__1
3300;
3301finally {
3302 restoreStackSize(stackSize);
3303}
3304
3305rule__ExternMetricDefinition__Group__0__Impl
3306 @init {
3307 int stackSize = keepStackSize();
3308 }
3309:
3310(
3311 { before(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); }
3312 Extern
3313 { after(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); }
3314)
3315;
3316finally {
3317 restoreStackSize(stackSize);
3318}
3319
3320rule__ExternMetricDefinition__Group__1
3321 @init {
3322 int stackSize = keepStackSize();
3323 }
3324:
3325 rule__ExternMetricDefinition__Group__1__Impl
3326 rule__ExternMetricDefinition__Group__2
3327;
3328finally {
3329 restoreStackSize(stackSize);
3330}
3331
3332rule__ExternMetricDefinition__Group__1__Impl
3333 @init {
3334 int stackSize = keepStackSize();
3335 }
3336:
3337(
3338 { before(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); }
3339 (rule__ExternMetricDefinition__TypeAssignment_1)
3340 { after(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); }
3341)
3342;
3343finally {
3344 restoreStackSize(stackSize);
3345}
3346
3347rule__ExternMetricDefinition__Group__2
3348 @init {
3349 int stackSize = keepStackSize();
3350 }
3351:
3352 rule__ExternMetricDefinition__Group__2__Impl
3353;
3354finally {
3355 restoreStackSize(stackSize);
3356}
3357
3358rule__ExternMetricDefinition__Group__2__Impl
3359 @init {
3360 int stackSize = keepStackSize();
3361 }
3362:
3363(
3364 { before(grammarAccess.getExternMetricDefinitionAccess().getHeadAssignment_2()); }
3365 (rule__ExternMetricDefinition__HeadAssignment_2)
3366 { after(grammarAccess.getExternMetricDefinitionAccess().getHeadAssignment_2()); }
3367)
3368;
3369finally {
3370 restoreStackSize(stackSize);
3371}
3372
3373
3374rule__IfElse__Group__0
3375 @init {
3376 int stackSize = keepStackSize();
3377 }
3378:
3379 rule__IfElse__Group__0__Impl
3380 rule__IfElse__Group__1
3381;
3382finally {
3383 restoreStackSize(stackSize);
3384}
3385
3386rule__IfElse__Group__0__Impl
3387 @init {
3388 int stackSize = keepStackSize();
3389 }
3390:
3391(
3392 { before(grammarAccess.getIfElseAccess().getIfKeyword_0()); }
3393 If
3394 { after(grammarAccess.getIfElseAccess().getIfKeyword_0()); }
3395)
3396;
3397finally {
3398 restoreStackSize(stackSize);
3399}
3400
3401rule__IfElse__Group__1
3402 @init {
3403 int stackSize = keepStackSize();
3404 }
3405:
3406 rule__IfElse__Group__1__Impl
3407 rule__IfElse__Group__2
3408;
3409finally {
3410 restoreStackSize(stackSize);
3411}
3412
3413rule__IfElse__Group__1__Impl
3414 @init {
3415 int stackSize = keepStackSize();
3416 }
3417:
3418(
3419 { before(grammarAccess.getIfElseAccess().getConditionAssignment_1()); }
3420 (rule__IfElse__ConditionAssignment_1)
3421 { after(grammarAccess.getIfElseAccess().getConditionAssignment_1()); }
3422)
3423;
3424finally {
3425 restoreStackSize(stackSize);
3426}
3427
3428rule__IfElse__Group__2
3429 @init {
3430 int stackSize = keepStackSize();
3431 }
3432:
3433 rule__IfElse__Group__2__Impl
3434 rule__IfElse__Group__3
3435;
3436finally {
3437 restoreStackSize(stackSize);
3438}
3439
3440rule__IfElse__Group__2__Impl
3441 @init {
3442 int stackSize = keepStackSize();
3443 }
3444:
3445(
3446 { before(grammarAccess.getIfElseAccess().getThenKeyword_2()); }
3447 Then
3448 { after(grammarAccess.getIfElseAccess().getThenKeyword_2()); }
3449)
3450;
3451finally {
3452 restoreStackSize(stackSize);
3453}
3454
3455rule__IfElse__Group__3
3456 @init {
3457 int stackSize = keepStackSize();
3458 }
3459:
3460 rule__IfElse__Group__3__Impl
3461 rule__IfElse__Group__4
3462;
3463finally {
3464 restoreStackSize(stackSize);
3465}
3466
3467rule__IfElse__Group__3__Impl
3468 @init {
3469 int stackSize = keepStackSize();
3470 }
3471:
3472(
3473 { before(grammarAccess.getIfElseAccess().getThenAssignment_3()); }
3474 (rule__IfElse__ThenAssignment_3)
3475 { after(grammarAccess.getIfElseAccess().getThenAssignment_3()); }
3476)
3477;
3478finally {
3479 restoreStackSize(stackSize);
3480}
3481
3482rule__IfElse__Group__4
3483 @init {
3484 int stackSize = keepStackSize();
3485 }
3486:
3487 rule__IfElse__Group__4__Impl
3488 rule__IfElse__Group__5
3489;
3490finally {
3491 restoreStackSize(stackSize);
3492}
3493
3494rule__IfElse__Group__4__Impl
3495 @init {
3496 int stackSize = keepStackSize();
3497 }
3498:
3499(
3500 { before(grammarAccess.getIfElseAccess().getElseKeyword_4()); }
3501 Else
3502 { after(grammarAccess.getIfElseAccess().getElseKeyword_4()); }
3503)
3504;
3505finally {
3506 restoreStackSize(stackSize);
3507}
3508
3509rule__IfElse__Group__5
3510 @init {
3511 int stackSize = keepStackSize();
3512 }
3513:
3514 rule__IfElse__Group__5__Impl
3515;
3516finally {
3517 restoreStackSize(stackSize);
3518}
3519
3520rule__IfElse__Group__5__Impl
3521 @init {
3522 int stackSize = keepStackSize();
3523 }
3524:
3525(
3526 { before(grammarAccess.getIfElseAccess().getElseAssignment_5()); }
3527 (rule__IfElse__ElseAssignment_5)
3528 { after(grammarAccess.getIfElseAccess().getElseAssignment_5()); }
3529)
3530;
3531finally {
3532 restoreStackSize(stackSize);
3533}
3534
3535
3536rule__DisjunctiveExpression__Group__0
3537 @init {
3538 int stackSize = keepStackSize();
3539 }
3540:
3541 rule__DisjunctiveExpression__Group__0__Impl
3542 rule__DisjunctiveExpression__Group__1
3543;
3544finally {
3545 restoreStackSize(stackSize);
3546}
3547
3548rule__DisjunctiveExpression__Group__0__Impl
3549 @init {
3550 int stackSize = keepStackSize();
3551 }
3552:
3553(
3554 { before(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); }
3555 ruleConjunctiveExpression
3556 { after(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); }
3557)
3558;
3559finally {
3560 restoreStackSize(stackSize);
3561}
3562
3563rule__DisjunctiveExpression__Group__1
3564 @init {
3565 int stackSize = keepStackSize();
3566 }
3567:
3568 rule__DisjunctiveExpression__Group__1__Impl
3569;
3570finally {
3571 restoreStackSize(stackSize);
3572}
3573
3574rule__DisjunctiveExpression__Group__1__Impl
3575 @init {
3576 int stackSize = keepStackSize();
3577 }
3578:
3579(
3580 { before(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); }
3581 (rule__DisjunctiveExpression__Alternatives_1)?
3582 { after(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); }
3583)
3584;
3585finally {
3586 restoreStackSize(stackSize);
3587}
3588
3589
3590rule__DisjunctiveExpression__Group_1_0__0
3591 @init {
3592 int stackSize = keepStackSize();
3593 }
3594:
3595 rule__DisjunctiveExpression__Group_1_0__0__Impl
3596 rule__DisjunctiveExpression__Group_1_0__1
3597;
3598finally {
3599 restoreStackSize(stackSize);
3600}
3601
3602rule__DisjunctiveExpression__Group_1_0__0__Impl
3603 @init {
3604 int stackSize = keepStackSize();
3605 }
3606:
3607(
3608 { before(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); }
3609 ()
3610 { after(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); }
3611)
3612;
3613finally {
3614 restoreStackSize(stackSize);
3615}
3616
3617rule__DisjunctiveExpression__Group_1_0__1
3618 @init {
3619 int stackSize = keepStackSize();
3620 }
3621:
3622 rule__DisjunctiveExpression__Group_1_0__1__Impl
3623;
3624finally {
3625 restoreStackSize(stackSize);
3626}
3627
3628rule__DisjunctiveExpression__Group_1_0__1__Impl
3629 @init {
3630 int stackSize = keepStackSize();
3631 }
3632:
3633(
3634 (
3635 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
3636 (rule__DisjunctiveExpression__Group_1_0_1__0)
3637 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
3638 )
3639 (
3640 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
3641 (rule__DisjunctiveExpression__Group_1_0_1__0)*
3642 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
3643 )
3644)
3645;
3646finally {
3647 restoreStackSize(stackSize);
3648}
3649
3650
3651rule__DisjunctiveExpression__Group_1_0_1__0
3652 @init {
3653 int stackSize = keepStackSize();
3654 }
3655:
3656 rule__DisjunctiveExpression__Group_1_0_1__0__Impl
3657 rule__DisjunctiveExpression__Group_1_0_1__1
3658;
3659finally {
3660 restoreStackSize(stackSize);
3661}
3662
3663rule__DisjunctiveExpression__Group_1_0_1__0__Impl
3664 @init {
3665 int stackSize = keepStackSize();
3666 }
3667:
3668(
3669 { before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); }
3670 Semicolon
3671 { after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); }
3672)
3673;
3674finally {
3675 restoreStackSize(stackSize);
3676}
3677
3678rule__DisjunctiveExpression__Group_1_0_1__1
3679 @init {
3680 int stackSize = keepStackSize();
3681 }
3682:
3683 rule__DisjunctiveExpression__Group_1_0_1__1__Impl
3684;
3685finally {
3686 restoreStackSize(stackSize);
3687}
3688
3689rule__DisjunctiveExpression__Group_1_0_1__1__Impl
3690 @init {
3691 int stackSize = keepStackSize();
3692 }
3693:
3694(
3695 { before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); }
3696 (rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1)
3697 { after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); }
3698)
3699;
3700finally {
3701 restoreStackSize(stackSize);
3702}
3703
3704
3705rule__DisjunctiveExpression__Group_1_1__0
3706 @init {
3707 int stackSize = keepStackSize();
3708 }
3709:
3710 rule__DisjunctiveExpression__Group_1_1__0__Impl
3711 rule__DisjunctiveExpression__Group_1_1__1
3712;
3713finally {
3714 restoreStackSize(stackSize);
3715}
3716
3717rule__DisjunctiveExpression__Group_1_1__0__Impl
3718 @init {
3719 int stackSize = keepStackSize();
3720 }
3721:
3722(
3723 { before(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); }
3724 ()
3725 { after(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); }
3726)
3727;
3728finally {
3729 restoreStackSize(stackSize);
3730}
3731
3732rule__DisjunctiveExpression__Group_1_1__1
3733 @init {
3734 int stackSize = keepStackSize();
3735 }
3736:
3737 rule__DisjunctiveExpression__Group_1_1__1__Impl
3738 rule__DisjunctiveExpression__Group_1_1__2
3739;
3740finally {
3741 restoreStackSize(stackSize);
3742}
3743
3744rule__DisjunctiveExpression__Group_1_1__1__Impl
3745 @init {
3746 int stackSize = keepStackSize();
3747 }
3748:
3749(
3750 { before(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); }
3751 HyphenMinusGreaterThanSign
3752 { after(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); }
3753)
3754;
3755finally {
3756 restoreStackSize(stackSize);
3757}
3758
3759rule__DisjunctiveExpression__Group_1_1__2
3760 @init {
3761 int stackSize = keepStackSize();
3762 }
3763:
3764 rule__DisjunctiveExpression__Group_1_1__2__Impl
3765 rule__DisjunctiveExpression__Group_1_1__3
3766;
3767finally {
3768 restoreStackSize(stackSize);
3769}
3770
3771rule__DisjunctiveExpression__Group_1_1__2__Impl
3772 @init {
3773 int stackSize = keepStackSize();
3774 }
3775:
3776(
3777 { before(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); }
3778 (rule__DisjunctiveExpression__BodyAssignment_1_1_2)
3779 { after(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); }
3780)
3781;
3782finally {
3783 restoreStackSize(stackSize);
3784}
3785
3786rule__DisjunctiveExpression__Group_1_1__3
3787 @init {
3788 int stackSize = keepStackSize();
3789 }
3790:
3791 rule__DisjunctiveExpression__Group_1_1__3__Impl
3792 rule__DisjunctiveExpression__Group_1_1__4
3793;
3794finally {
3795 restoreStackSize(stackSize);
3796}
3797
3798rule__DisjunctiveExpression__Group_1_1__3__Impl
3799 @init {
3800 int stackSize = keepStackSize();
3801 }
3802:
3803(
3804 { before(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); }
3805 ()
3806 { after(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); }
3807)
3808;
3809finally {
3810 restoreStackSize(stackSize);
3811}
3812
3813rule__DisjunctiveExpression__Group_1_1__4
3814 @init {
3815 int stackSize = keepStackSize();
3816 }
3817:
3818 rule__DisjunctiveExpression__Group_1_1__4__Impl
3819;
3820finally {
3821 restoreStackSize(stackSize);
3822}
3823
3824rule__DisjunctiveExpression__Group_1_1__4__Impl
3825 @init {
3826 int stackSize = keepStackSize();
3827 }
3828:
3829(
3830 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); }
3831 (rule__DisjunctiveExpression__Group_1_1_4__0)*
3832 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); }
3833)
3834;
3835finally {
3836 restoreStackSize(stackSize);
3837}
3838
3839
3840rule__DisjunctiveExpression__Group_1_1_4__0
3841 @init {
3842 int stackSize = keepStackSize();
3843 }
3844:
3845 rule__DisjunctiveExpression__Group_1_1_4__0__Impl
3846 rule__DisjunctiveExpression__Group_1_1_4__1
3847;
3848finally {
3849 restoreStackSize(stackSize);
3850}
3851
3852rule__DisjunctiveExpression__Group_1_1_4__0__Impl
3853 @init {
3854 int stackSize = keepStackSize();
3855 }
3856:
3857(
3858 { before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); }
3859 Semicolon
3860 { after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); }
3861)
3862;
3863finally {
3864 restoreStackSize(stackSize);
3865}
3866
3867rule__DisjunctiveExpression__Group_1_1_4__1
3868 @init {
3869 int stackSize = keepStackSize();
3870 }
3871:
3872 rule__DisjunctiveExpression__Group_1_1_4__1__Impl
3873;
3874finally {
3875 restoreStackSize(stackSize);
3876}
3877
3878rule__DisjunctiveExpression__Group_1_1_4__1__Impl
3879 @init {
3880 int stackSize = keepStackSize();
3881 }
3882:
3883(
3884 { before(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); }
3885 (rule__DisjunctiveExpression__CasesAssignment_1_1_4_1)
3886 { after(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); }
3887)
3888;
3889finally {
3890 restoreStackSize(stackSize);
3891}
3892
3893
3894rule__Case__Group__0
3895 @init {
3896 int stackSize = keepStackSize();
3897 }
3898:
3899 rule__Case__Group__0__Impl
3900 rule__Case__Group__1
3901;
3902finally {
3903 restoreStackSize(stackSize);
3904}
3905
3906rule__Case__Group__0__Impl
3907 @init {
3908 int stackSize = keepStackSize();
3909 }
3910:
3911(
3912 { before(grammarAccess.getCaseAccess().getConditionAssignment_0()); }
3913 (rule__Case__ConditionAssignment_0)
3914 { after(grammarAccess.getCaseAccess().getConditionAssignment_0()); }
3915)
3916;
3917finally {
3918 restoreStackSize(stackSize);
3919}
3920
3921rule__Case__Group__1
3922 @init {
3923 int stackSize = keepStackSize();
3924 }
3925:
3926 rule__Case__Group__1__Impl
3927 rule__Case__Group__2
3928;
3929finally {
3930 restoreStackSize(stackSize);
3931}
3932
3933rule__Case__Group__1__Impl
3934 @init {
3935 int stackSize = keepStackSize();
3936 }
3937:
3938(
3939 { before(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); }
3940 HyphenMinusGreaterThanSign
3941 { after(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); }
3942)
3943;
3944finally {
3945 restoreStackSize(stackSize);
3946}
3947
3948rule__Case__Group__2
3949 @init {
3950 int stackSize = keepStackSize();
3951 }
3952:
3953 rule__Case__Group__2__Impl
3954;
3955finally {
3956 restoreStackSize(stackSize);
3957}
3958
3959rule__Case__Group__2__Impl
3960 @init {
3961 int stackSize = keepStackSize();
3962 }
3963:
3964(
3965 { before(grammarAccess.getCaseAccess().getBodyAssignment_2()); }
3966 (rule__Case__BodyAssignment_2)
3967 { after(grammarAccess.getCaseAccess().getBodyAssignment_2()); }
3968)
3969;
3970finally {
3971 restoreStackSize(stackSize);
3972}
3973
3974
3975rule__ConjunctiveExpression__Group__0
3976 @init {
3977 int stackSize = keepStackSize();
3978 }
3979:
3980 rule__ConjunctiveExpression__Group__0__Impl
3981 rule__ConjunctiveExpression__Group__1
3982;
3983finally {
3984 restoreStackSize(stackSize);
3985}
3986
3987rule__ConjunctiveExpression__Group__0__Impl
3988 @init {
3989 int stackSize = keepStackSize();
3990 }
3991:
3992(
3993 { before(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); }
3994 ruleComparisonExpression
3995 { after(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); }
3996)
3997;
3998finally {
3999 restoreStackSize(stackSize);
4000}
4001
4002rule__ConjunctiveExpression__Group__1
4003 @init {
4004 int stackSize = keepStackSize();
4005 }
4006:
4007 rule__ConjunctiveExpression__Group__1__Impl
4008;
4009finally {
4010 restoreStackSize(stackSize);
4011}
4012
4013rule__ConjunctiveExpression__Group__1__Impl
4014 @init {
4015 int stackSize = keepStackSize();
4016 }
4017:
4018(
4019 { before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); }
4020 (rule__ConjunctiveExpression__Group_1__0)?
4021 { after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); }
4022)
4023;
4024finally {
4025 restoreStackSize(stackSize);
4026}
4027
4028
4029rule__ConjunctiveExpression__Group_1__0
4030 @init {
4031 int stackSize = keepStackSize();
4032 }
4033:
4034 rule__ConjunctiveExpression__Group_1__0__Impl
4035 rule__ConjunctiveExpression__Group_1__1
4036;
4037finally {
4038 restoreStackSize(stackSize);
4039}
4040
4041rule__ConjunctiveExpression__Group_1__0__Impl
4042 @init {
4043 int stackSize = keepStackSize();
4044 }
4045:
4046(
4047 { before(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); }
4048 ()
4049 { after(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); }
4050)
4051;
4052finally {
4053 restoreStackSize(stackSize);
4054}
4055
4056rule__ConjunctiveExpression__Group_1__1
4057 @init {
4058 int stackSize = keepStackSize();
4059 }
4060:
4061 rule__ConjunctiveExpression__Group_1__1__Impl
4062;
4063finally {
4064 restoreStackSize(stackSize);
4065}
4066
4067rule__ConjunctiveExpression__Group_1__1__Impl
4068 @init {
4069 int stackSize = keepStackSize();
4070 }
4071:
4072(
4073 (
4074 { before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
4075 (rule__ConjunctiveExpression__Group_1_1__0)
4076 { after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
4077 )
4078 (
4079 { before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
4080 (rule__ConjunctiveExpression__Group_1_1__0)*
4081 { after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
4082 )
4083)
4084;
4085finally {
4086 restoreStackSize(stackSize);
4087}
4088
4089
4090rule__ConjunctiveExpression__Group_1_1__0
4091 @init {
4092 int stackSize = keepStackSize();
4093 }
4094:
4095 rule__ConjunctiveExpression__Group_1_1__0__Impl
4096 rule__ConjunctiveExpression__Group_1_1__1
4097;
4098finally {
4099 restoreStackSize(stackSize);
4100}
4101
4102rule__ConjunctiveExpression__Group_1_1__0__Impl
4103 @init {
4104 int stackSize = keepStackSize();
4105 }
4106:
4107(
4108 { before(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); }
4109 Comma
4110 { after(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); }
4111)
4112;
4113finally {
4114 restoreStackSize(stackSize);
4115}
4116
4117rule__ConjunctiveExpression__Group_1_1__1
4118 @init {
4119 int stackSize = keepStackSize();
4120 }
4121:
4122 rule__ConjunctiveExpression__Group_1_1__1__Impl
4123;
4124finally {
4125 restoreStackSize(stackSize);
4126}
4127
4128rule__ConjunctiveExpression__Group_1_1__1__Impl
4129 @init {
4130 int stackSize = keepStackSize();
4131 }
4132:
4133(
4134 { before(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); }
4135 (rule__ConjunctiveExpression__ChildrenAssignment_1_1_1)
4136 { after(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); }
4137)
4138;
4139finally {
4140 restoreStackSize(stackSize);
4141}
4142
4143
4144rule__ComparisonExpression__Group__0
4145 @init {
4146 int stackSize = keepStackSize();
4147 }
4148:
4149 rule__ComparisonExpression__Group__0__Impl
4150 rule__ComparisonExpression__Group__1
4151;
4152finally {
4153 restoreStackSize(stackSize);
4154}
4155
4156rule__ComparisonExpression__Group__0__Impl
4157 @init {
4158 int stackSize = keepStackSize();
4159 }
4160:
4161(
4162 { before(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); }
4163 ruleAdditiveExpression
4164 { after(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); }
4165)
4166;
4167finally {
4168 restoreStackSize(stackSize);
4169}
4170
4171rule__ComparisonExpression__Group__1
4172 @init {
4173 int stackSize = keepStackSize();
4174 }
4175:
4176 rule__ComparisonExpression__Group__1__Impl
4177;
4178finally {
4179 restoreStackSize(stackSize);
4180}
4181
4182rule__ComparisonExpression__Group__1__Impl
4183 @init {
4184 int stackSize = keepStackSize();
4185 }
4186:
4187(
4188 { before(grammarAccess.getComparisonExpressionAccess().getGroup_1()); }
4189 (rule__ComparisonExpression__Group_1__0)?
4190 { after(grammarAccess.getComparisonExpressionAccess().getGroup_1()); }
4191)
4192;
4193finally {
4194 restoreStackSize(stackSize);
4195}
4196
4197
4198rule__ComparisonExpression__Group_1__0
4199 @init {
4200 int stackSize = keepStackSize();
4201 }
4202:
4203 rule__ComparisonExpression__Group_1__0__Impl
4204 rule__ComparisonExpression__Group_1__1
4205;
4206finally {
4207 restoreStackSize(stackSize);
4208}
4209
4210rule__ComparisonExpression__Group_1__0__Impl
4211 @init {
4212 int stackSize = keepStackSize();
4213 }
4214:
4215(
4216 { before(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0()); }
4217 ()
4218 { after(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0()); }
4219)
4220;
4221finally {
4222 restoreStackSize(stackSize);
4223}
4224
4225rule__ComparisonExpression__Group_1__1
4226 @init {
4227 int stackSize = keepStackSize();
4228 }
4229:
4230 rule__ComparisonExpression__Group_1__1__Impl
4231 rule__ComparisonExpression__Group_1__2
4232;
4233finally {
4234 restoreStackSize(stackSize);
4235}
4236
4237rule__ComparisonExpression__Group_1__1__Impl
4238 @init {
4239 int stackSize = keepStackSize();
4240 }
4241:
4242(
4243 { before(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); }
4244 (rule__ComparisonExpression__OpAssignment_1_1)
4245 { after(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); }
4246)
4247;
4248finally {
4249 restoreStackSize(stackSize);
4250}
4251
4252rule__ComparisonExpression__Group_1__2
4253 @init {
4254 int stackSize = keepStackSize();
4255 }
4256:
4257 rule__ComparisonExpression__Group_1__2__Impl
4258;
4259finally {
4260 restoreStackSize(stackSize);
4261}
4262
4263rule__ComparisonExpression__Group_1__2__Impl
4264 @init {
4265 int stackSize = keepStackSize();
4266 }
4267:
4268(
4269 { before(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); }
4270 (rule__ComparisonExpression__RightAssignment_1_2)
4271 { after(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); }
4272)
4273;
4274finally {
4275 restoreStackSize(stackSize);
4276}
4277
4278
4279rule__AdditiveExpression__Group__0
4280 @init {
4281 int stackSize = keepStackSize();
4282 }
4283:
4284 rule__AdditiveExpression__Group__0__Impl
4285 rule__AdditiveExpression__Group__1
4286;
4287finally {
4288 restoreStackSize(stackSize);
4289}
4290
4291rule__AdditiveExpression__Group__0__Impl
4292 @init {
4293 int stackSize = keepStackSize();
4294 }
4295:
4296(
4297 { before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); }
4298 ruleMultiplicativeExpression
4299 { after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); }
4300)
4301;
4302finally {
4303 restoreStackSize(stackSize);
4304}
4305
4306rule__AdditiveExpression__Group__1
4307 @init {
4308 int stackSize = keepStackSize();
4309 }
4310:
4311 rule__AdditiveExpression__Group__1__Impl
4312;
4313finally {
4314 restoreStackSize(stackSize);
4315}
4316
4317rule__AdditiveExpression__Group__1__Impl
4318 @init {
4319 int stackSize = keepStackSize();
4320 }
4321:
4322(
4323 { before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); }
4324 (rule__AdditiveExpression__Group_1__0)*
4325 { after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); }
4326)
4327;
4328finally {
4329 restoreStackSize(stackSize);
4330}
4331
4332
4333rule__AdditiveExpression__Group_1__0
4334 @init {
4335 int stackSize = keepStackSize();
4336 }
4337:
4338 rule__AdditiveExpression__Group_1__0__Impl
4339 rule__AdditiveExpression__Group_1__1
4340;
4341finally {
4342 restoreStackSize(stackSize);
4343}
4344
4345rule__AdditiveExpression__Group_1__0__Impl
4346 @init {
4347 int stackSize = keepStackSize();
4348 }
4349:
4350(
4351 { before(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
4352 ()
4353 { after(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
4354)
4355;
4356finally {
4357 restoreStackSize(stackSize);
4358}
4359
4360rule__AdditiveExpression__Group_1__1
4361 @init {
4362 int stackSize = keepStackSize();
4363 }
4364:
4365 rule__AdditiveExpression__Group_1__1__Impl
4366 rule__AdditiveExpression__Group_1__2
4367;
4368finally {
4369 restoreStackSize(stackSize);
4370}
4371
4372rule__AdditiveExpression__Group_1__1__Impl
4373 @init {
4374 int stackSize = keepStackSize();
4375 }
4376:
4377(
4378 { before(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); }
4379 (rule__AdditiveExpression__OpAssignment_1_1)
4380 { after(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); }
4381)
4382;
4383finally {
4384 restoreStackSize(stackSize);
4385}
4386
4387rule__AdditiveExpression__Group_1__2
4388 @init {
4389 int stackSize = keepStackSize();
4390 }
4391:
4392 rule__AdditiveExpression__Group_1__2__Impl
4393;
4394finally {
4395 restoreStackSize(stackSize);
4396}
4397
4398rule__AdditiveExpression__Group_1__2__Impl
4399 @init {
4400 int stackSize = keepStackSize();
4401 }
4402:
4403(
4404 { before(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); }
4405 (rule__AdditiveExpression__RightAssignment_1_2)
4406 { after(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); }
4407)
4408;
4409finally {
4410 restoreStackSize(stackSize);
4411}
4412
4413
4414rule__MultiplicativeExpression__Group__0
4415 @init {
4416 int stackSize = keepStackSize();
4417 }
4418:
4419 rule__MultiplicativeExpression__Group__0__Impl
4420 rule__MultiplicativeExpression__Group__1
4421;
4422finally {
4423 restoreStackSize(stackSize);
4424}
4425
4426rule__MultiplicativeExpression__Group__0__Impl
4427 @init {
4428 int stackSize = keepStackSize();
4429 }
4430:
4431(
4432 { before(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); }
4433 ruleExponentialExpression
4434 { after(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); }
4435)
4436;
4437finally {
4438 restoreStackSize(stackSize);
4439}
4440
4441rule__MultiplicativeExpression__Group__1
4442 @init {
4443 int stackSize = keepStackSize();
4444 }
4445:
4446 rule__MultiplicativeExpression__Group__1__Impl
4447;
4448finally {
4449 restoreStackSize(stackSize);
4450}
4451
4452rule__MultiplicativeExpression__Group__1__Impl
4453 @init {
4454 int stackSize = keepStackSize();
4455 }
4456:
4457(
4458 { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); }
4459 (rule__MultiplicativeExpression__Group_1__0)*
4460 { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); }
4461)
4462;
4463finally {
4464 restoreStackSize(stackSize);
4465}
4466
4467
4468rule__MultiplicativeExpression__Group_1__0
4469 @init {
4470 int stackSize = keepStackSize();
4471 }
4472:
4473 rule__MultiplicativeExpression__Group_1__0__Impl
4474 rule__MultiplicativeExpression__Group_1__1
4475;
4476finally {
4477 restoreStackSize(stackSize);
4478}
4479
4480rule__MultiplicativeExpression__Group_1__0__Impl
4481 @init {
4482 int stackSize = keepStackSize();
4483 }
4484:
4485(
4486 { before(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
4487 ()
4488 { after(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
4489)
4490;
4491finally {
4492 restoreStackSize(stackSize);
4493}
4494
4495rule__MultiplicativeExpression__Group_1__1
4496 @init {
4497 int stackSize = keepStackSize();
4498 }
4499:
4500 rule__MultiplicativeExpression__Group_1__1__Impl
4501 rule__MultiplicativeExpression__Group_1__2
4502;
4503finally {
4504 restoreStackSize(stackSize);
4505}
4506
4507rule__MultiplicativeExpression__Group_1__1__Impl
4508 @init {
4509 int stackSize = keepStackSize();
4510 }
4511:
4512(
4513 { before(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); }
4514 (rule__MultiplicativeExpression__OpAssignment_1_1)
4515 { after(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); }
4516)
4517;
4518finally {
4519 restoreStackSize(stackSize);
4520}
4521
4522rule__MultiplicativeExpression__Group_1__2
4523 @init {
4524 int stackSize = keepStackSize();
4525 }
4526:
4527 rule__MultiplicativeExpression__Group_1__2__Impl
4528;
4529finally {
4530 restoreStackSize(stackSize);
4531}
4532
4533rule__MultiplicativeExpression__Group_1__2__Impl
4534 @init {
4535 int stackSize = keepStackSize();
4536 }
4537:
4538(
4539 { before(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); }
4540 (rule__MultiplicativeExpression__RightAssignment_1_2)
4541 { after(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); }
4542)
4543;
4544finally {
4545 restoreStackSize(stackSize);
4546}
4547
4548
4549rule__ExponentialExpression__Group__0
4550 @init {
4551 int stackSize = keepStackSize();
4552 }
4553:
4554 rule__ExponentialExpression__Group__0__Impl
4555 rule__ExponentialExpression__Group__1
4556;
4557finally {
4558 restoreStackSize(stackSize);
4559}
4560
4561rule__ExponentialExpression__Group__0__Impl
4562 @init {
4563 int stackSize = keepStackSize();
4564 }
4565:
4566(
4567 { before(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); }
4568 ruleUnaryExpression
4569 { after(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); }
4570)
4571;
4572finally {
4573 restoreStackSize(stackSize);
4574}
4575
4576rule__ExponentialExpression__Group__1
4577 @init {
4578 int stackSize = keepStackSize();
4579 }
4580:
4581 rule__ExponentialExpression__Group__1__Impl
4582;
4583finally {
4584 restoreStackSize(stackSize);
4585}
4586
4587rule__ExponentialExpression__Group__1__Impl
4588 @init {
4589 int stackSize = keepStackSize();
4590 }
4591:
4592(
4593 { before(grammarAccess.getExponentialExpressionAccess().getGroup_1()); }
4594 (rule__ExponentialExpression__Group_1__0)?
4595 { after(grammarAccess.getExponentialExpressionAccess().getGroup_1()); }
4596)
4597;
4598finally {
4599 restoreStackSize(stackSize);
4600}
4601
4602
4603rule__ExponentialExpression__Group_1__0
4604 @init {
4605 int stackSize = keepStackSize();
4606 }
4607:
4608 rule__ExponentialExpression__Group_1__0__Impl
4609 rule__ExponentialExpression__Group_1__1
4610;
4611finally {
4612 restoreStackSize(stackSize);
4613}
4614
4615rule__ExponentialExpression__Group_1__0__Impl
4616 @init {
4617 int stackSize = keepStackSize();
4618 }
4619:
4620(
4621 { before(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
4622 ()
4623 { after(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
4624)
4625;
4626finally {
4627 restoreStackSize(stackSize);
4628}
4629
4630rule__ExponentialExpression__Group_1__1
4631 @init {
4632 int stackSize = keepStackSize();
4633 }
4634:
4635 rule__ExponentialExpression__Group_1__1__Impl
4636 rule__ExponentialExpression__Group_1__2
4637;
4638finally {
4639 restoreStackSize(stackSize);
4640}
4641
4642rule__ExponentialExpression__Group_1__1__Impl
4643 @init {
4644 int stackSize = keepStackSize();
4645 }
4646:
4647(
4648 { before(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); }
4649 (rule__ExponentialExpression__OpAssignment_1_1)
4650 { after(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); }
4651)
4652;
4653finally {
4654 restoreStackSize(stackSize);
4655}
4656
4657rule__ExponentialExpression__Group_1__2
4658 @init {
4659 int stackSize = keepStackSize();
4660 }
4661:
4662 rule__ExponentialExpression__Group_1__2__Impl
4663;
4664finally {
4665 restoreStackSize(stackSize);
4666}
4667
4668rule__ExponentialExpression__Group_1__2__Impl
4669 @init {
4670 int stackSize = keepStackSize();
4671 }
4672:
4673(
4674 { before(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); }
4675 (rule__ExponentialExpression__RightAssignment_1_2)
4676 { after(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); }
4677)
4678;
4679finally {
4680 restoreStackSize(stackSize);
4681}
4682
4683
4684rule__UnaryExpression__Group_1__0
4685 @init {
4686 int stackSize = keepStackSize();
4687 }
4688:
4689 rule__UnaryExpression__Group_1__0__Impl
4690 rule__UnaryExpression__Group_1__1
4691;
4692finally {
4693 restoreStackSize(stackSize);
4694}
4695
4696rule__UnaryExpression__Group_1__0__Impl
4697 @init {
4698 int stackSize = keepStackSize();
4699 }
4700:
4701(
4702 { before(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); }
4703 ()
4704 { after(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); }
4705)
4706;
4707finally {
4708 restoreStackSize(stackSize);
4709}
4710
4711rule__UnaryExpression__Group_1__1
4712 @init {
4713 int stackSize = keepStackSize();
4714 }
4715:
4716 rule__UnaryExpression__Group_1__1__Impl
4717 rule__UnaryExpression__Group_1__2
4718;
4719finally {
4720 restoreStackSize(stackSize);
4721}
4722
4723rule__UnaryExpression__Group_1__1__Impl
4724 @init {
4725 int stackSize = keepStackSize();
4726 }
4727:
4728(
4729 { before(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); }
4730 (rule__UnaryExpression__OpAssignment_1_1)
4731 { after(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); }
4732)
4733;
4734finally {
4735 restoreStackSize(stackSize);
4736}
4737
4738rule__UnaryExpression__Group_1__2
4739 @init {
4740 int stackSize = keepStackSize();
4741 }
4742:
4743 rule__UnaryExpression__Group_1__2__Impl
4744;
4745finally {
4746 restoreStackSize(stackSize);
4747}
4748
4749rule__UnaryExpression__Group_1__2__Impl
4750 @init {
4751 int stackSize = keepStackSize();
4752 }
4753:
4754(
4755 { before(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); }
4756 (rule__UnaryExpression__BodyAssignment_1_2)
4757 { after(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); }
4758)
4759;
4760finally {
4761 restoreStackSize(stackSize);
4762}
4763
4764
4765rule__Count__Group__0
4766 @init {
4767 int stackSize = keepStackSize();
4768 }
4769:
4770 rule__Count__Group__0__Impl
4771 rule__Count__Group__1
4772;
4773finally {
4774 restoreStackSize(stackSize);
4775}
4776
4777rule__Count__Group__0__Impl
4778 @init {
4779 int stackSize = keepStackSize();
4780 }
4781:
4782(
4783 { before(grammarAccess.getCountAccess().getCountKeyword_0()); }
4784 Count
4785 { after(grammarAccess.getCountAccess().getCountKeyword_0()); }
4786)
4787;
4788finally {
4789 restoreStackSize(stackSize);
4790}
4791
4792rule__Count__Group__1
4793 @init {
4794 int stackSize = keepStackSize();
4795 }
4796:
4797 rule__Count__Group__1__Impl
4798 rule__Count__Group__2
4799;
4800finally {
4801 restoreStackSize(stackSize);
4802}
4803
4804rule__Count__Group__1__Impl
4805 @init {
4806 int stackSize = keepStackSize();
4807 }
4808:
4809(
4810 { before(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); }
4811 LeftCurlyBracket
4812 { after(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); }
4813)
4814;
4815finally {
4816 restoreStackSize(stackSize);
4817}
4818
4819rule__Count__Group__2
4820 @init {
4821 int stackSize = keepStackSize();
4822 }
4823:
4824 rule__Count__Group__2__Impl
4825 rule__Count__Group__3
4826;
4827finally {
4828 restoreStackSize(stackSize);
4829}
4830
4831rule__Count__Group__2__Impl
4832 @init {
4833 int stackSize = keepStackSize();
4834 }
4835:
4836(
4837 { before(grammarAccess.getCountAccess().getBodyAssignment_2()); }
4838 (rule__Count__BodyAssignment_2)
4839 { after(grammarAccess.getCountAccess().getBodyAssignment_2()); }
4840)
4841;
4842finally {
4843 restoreStackSize(stackSize);
4844}
4845
4846rule__Count__Group__3
4847 @init {
4848 int stackSize = keepStackSize();
4849 }
4850:
4851 rule__Count__Group__3__Impl
4852;
4853finally {
4854 restoreStackSize(stackSize);
4855}
4856
4857rule__Count__Group__3__Impl
4858 @init {
4859 int stackSize = keepStackSize();
4860 }
4861:
4862(
4863 { before(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); }
4864 RightCurlyBracket
4865 { after(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); }
4866)
4867;
4868finally {
4869 restoreStackSize(stackSize);
4870}
4871
4872
4873rule__Aggregation__Group__0
4874 @init {
4875 int stackSize = keepStackSize();
4876 }
4877:
4878 rule__Aggregation__Group__0__Impl
4879 rule__Aggregation__Group__1
4880;
4881finally {
4882 restoreStackSize(stackSize);
4883}
4884
4885rule__Aggregation__Group__0__Impl
4886 @init {
4887 int stackSize = keepStackSize();
4888 }
4889:
4890(
4891 { before(grammarAccess.getAggregationAccess().getOpAssignment_0()); }
4892 (rule__Aggregation__OpAssignment_0)
4893 { after(grammarAccess.getAggregationAccess().getOpAssignment_0()); }
4894)
4895;
4896finally {
4897 restoreStackSize(stackSize);
4898}
4899
4900rule__Aggregation__Group__1
4901 @init {
4902 int stackSize = keepStackSize();
4903 }
4904:
4905 rule__Aggregation__Group__1__Impl
4906 rule__Aggregation__Group__2
4907;
4908finally {
4909 restoreStackSize(stackSize);
4910}
4911
4912rule__Aggregation__Group__1__Impl
4913 @init {
4914 int stackSize = keepStackSize();
4915 }
4916:
4917(
4918 { before(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); }
4919 LeftCurlyBracket
4920 { after(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); }
4921)
4922;
4923finally {
4924 restoreStackSize(stackSize);
4925}
4926
4927rule__Aggregation__Group__2
4928 @init {
4929 int stackSize = keepStackSize();
4930 }
4931:
4932 rule__Aggregation__Group__2__Impl
4933 rule__Aggregation__Group__3
4934;
4935finally {
4936 restoreStackSize(stackSize);
4937}
4938
4939rule__Aggregation__Group__2__Impl
4940 @init {
4941 int stackSize = keepStackSize();
4942 }
4943:
4944(
4945 { before(grammarAccess.getAggregationAccess().getBodyAssignment_2()); }
4946 (rule__Aggregation__BodyAssignment_2)
4947 { after(grammarAccess.getAggregationAccess().getBodyAssignment_2()); }
4948)
4949;
4950finally {
4951 restoreStackSize(stackSize);
4952}
4953
4954rule__Aggregation__Group__3
4955 @init {
4956 int stackSize = keepStackSize();
4957 }
4958:
4959 rule__Aggregation__Group__3__Impl
4960 rule__Aggregation__Group__4
4961;
4962finally {
4963 restoreStackSize(stackSize);
4964}
4965
4966rule__Aggregation__Group__3__Impl
4967 @init {
4968 int stackSize = keepStackSize();
4969 }
4970:
4971(
4972 { before(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); }
4973 VerticalLine
4974 { after(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); }
4975)
4976;
4977finally {
4978 restoreStackSize(stackSize);
4979}
4980
4981rule__Aggregation__Group__4
4982 @init {
4983 int stackSize = keepStackSize();
4984 }
4985:
4986 rule__Aggregation__Group__4__Impl
4987 rule__Aggregation__Group__5
4988;
4989finally {
4990 restoreStackSize(stackSize);
4991}
4992
4993rule__Aggregation__Group__4__Impl
4994 @init {
4995 int stackSize = keepStackSize();
4996 }
4997:
4998(
4999 { before(grammarAccess.getAggregationAccess().getConditionAssignment_4()); }
5000 (rule__Aggregation__ConditionAssignment_4)
5001 { after(grammarAccess.getAggregationAccess().getConditionAssignment_4()); }
5002)
5003;
5004finally {
5005 restoreStackSize(stackSize);
5006}
5007
5008rule__Aggregation__Group__5
5009 @init {
5010 int stackSize = keepStackSize();
5011 }
5012:
5013 rule__Aggregation__Group__5__Impl
5014;
5015finally {
5016 restoreStackSize(stackSize);
5017}
5018
5019rule__Aggregation__Group__5__Impl
5020 @init {
5021 int stackSize = keepStackSize();
5022 }
5023:
5024(
5025 { before(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); }
5026 RightCurlyBracket
5027 { after(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); }
5028)
5029;
5030finally {
5031 restoreStackSize(stackSize);
5032}
5033
5034
5035rule__AtomicExpression__Group_4__0
5036 @init {
5037 int stackSize = keepStackSize();
5038 }
5039:
5040 rule__AtomicExpression__Group_4__0__Impl
5041 rule__AtomicExpression__Group_4__1
5042;
5043finally {
5044 restoreStackSize(stackSize);
5045}
5046
5047rule__AtomicExpression__Group_4__0__Impl
5048 @init {
5049 int stackSize = keepStackSize();
5050 }
5051:
5052(
5053 { before(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); }
5054 LeftParenthesis
5055 { after(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); }
5056)
5057;
5058finally {
5059 restoreStackSize(stackSize);
5060}
5061
5062rule__AtomicExpression__Group_4__1
5063 @init {
5064 int stackSize = keepStackSize();
5065 }
5066:
5067 rule__AtomicExpression__Group_4__1__Impl
5068 rule__AtomicExpression__Group_4__2
5069;
5070finally {
5071 restoreStackSize(stackSize);
5072}
5073
5074rule__AtomicExpression__Group_4__1__Impl
5075 @init {
5076 int stackSize = keepStackSize();
5077 }
5078:
5079(
5080 { before(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); }
5081 ruleExpression
5082 { after(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); }
5083)
5084;
5085finally {
5086 restoreStackSize(stackSize);
5087}
5088
5089rule__AtomicExpression__Group_4__2
5090 @init {
5091 int stackSize = keepStackSize();
5092 }
5093:
5094 rule__AtomicExpression__Group_4__2__Impl
5095;
5096finally {
5097 restoreStackSize(stackSize);
5098}
5099
5100rule__AtomicExpression__Group_4__2__Impl
5101 @init {
5102 int stackSize = keepStackSize();
5103 }
5104:
5105(
5106 { before(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); }
5107 RightParenthesis
5108 { after(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); }
5109)
5110;
5111finally {
5112 restoreStackSize(stackSize);
5113}
5114
5115
5116rule__Call__Group__0
5117 @init {
5118 int stackSize = keepStackSize();
5119 }
5120:
5121 rule__Call__Group__0__Impl
5122 rule__Call__Group__1
5123;
5124finally {
5125 restoreStackSize(stackSize);
5126}
5127
5128rule__Call__Group__0__Impl
5129 @init {
5130 int stackSize = keepStackSize();
5131 }
5132:
5133(
5134 { before(grammarAccess.getCallAccess().getFunctorAssignment_0()); }
5135 (rule__Call__FunctorAssignment_0)
5136 { after(grammarAccess.getCallAccess().getFunctorAssignment_0()); }
5137)
5138;
5139finally {
5140 restoreStackSize(stackSize);
5141}
5142
5143rule__Call__Group__1
5144 @init {
5145 int stackSize = keepStackSize();
5146 }
5147:
5148 rule__Call__Group__1__Impl
5149 rule__Call__Group__2
5150;
5151finally {
5152 restoreStackSize(stackSize);
5153}
5154
5155rule__Call__Group__1__Impl
5156 @init {
5157 int stackSize = keepStackSize();
5158 }
5159:
5160(
5161 { before(grammarAccess.getCallAccess().getAlternatives_1()); }
5162 (rule__Call__Alternatives_1)?
5163 { after(grammarAccess.getCallAccess().getAlternatives_1()); }
5164)
5165;
5166finally {
5167 restoreStackSize(stackSize);
5168}
5169
5170rule__Call__Group__2
5171 @init {
5172 int stackSize = keepStackSize();
5173 }
5174:
5175 rule__Call__Group__2__Impl
5176;
5177finally {
5178 restoreStackSize(stackSize);
5179}
5180
5181rule__Call__Group__2__Impl
5182 @init {
5183 int stackSize = keepStackSize();
5184 }
5185:
5186(
5187 { before(grammarAccess.getCallAccess().getArgumentListAssignment_2()); }
5188 (rule__Call__ArgumentListAssignment_2)
5189 { after(grammarAccess.getCallAccess().getArgumentListAssignment_2()); }
5190)
5191;
5192finally {
5193 restoreStackSize(stackSize);
5194}
5195
5196
5197rule__ArgumentList__Group__0
5198 @init {
5199 int stackSize = keepStackSize();
5200 }
5201:
5202 rule__ArgumentList__Group__0__Impl
5203 rule__ArgumentList__Group__1
5204;
5205finally {
5206 restoreStackSize(stackSize);
5207}
5208
5209rule__ArgumentList__Group__0__Impl
5210 @init {
5211 int stackSize = keepStackSize();
5212 }
5213:
5214(
5215 { before(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); }
5216 ()
5217 { after(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); }
5218)
5219;
5220finally {
5221 restoreStackSize(stackSize);
5222}
5223
5224rule__ArgumentList__Group__1
5225 @init {
5226 int stackSize = keepStackSize();
5227 }
5228:
5229 rule__ArgumentList__Group__1__Impl
5230 rule__ArgumentList__Group__2
5231;
5232finally {
5233 restoreStackSize(stackSize);
5234}
5235
5236rule__ArgumentList__Group__1__Impl
5237 @init {
5238 int stackSize = keepStackSize();
5239 }
5240:
5241(
5242 { before(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); }
5243 LeftParenthesis
5244 { after(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); }
5245)
5246;
5247finally {
5248 restoreStackSize(stackSize);
5249}
5250
5251rule__ArgumentList__Group__2
5252 @init {
5253 int stackSize = keepStackSize();
5254 }
5255:
5256 rule__ArgumentList__Group__2__Impl
5257 rule__ArgumentList__Group__3
5258;
5259finally {
5260 restoreStackSize(stackSize);
5261}
5262
5263rule__ArgumentList__Group__2__Impl
5264 @init {
5265 int stackSize = keepStackSize();
5266 }
5267:
5268(
5269 { before(grammarAccess.getArgumentListAccess().getGroup_2()); }
5270 (rule__ArgumentList__Group_2__0)?
5271 { after(grammarAccess.getArgumentListAccess().getGroup_2()); }
5272)
5273;
5274finally {
5275 restoreStackSize(stackSize);
5276}
5277
5278rule__ArgumentList__Group__3
5279 @init {
5280 int stackSize = keepStackSize();
5281 }
5282:
5283 rule__ArgumentList__Group__3__Impl
5284;
5285finally {
5286 restoreStackSize(stackSize);
5287}
5288
5289rule__ArgumentList__Group__3__Impl
5290 @init {
5291 int stackSize = keepStackSize();
5292 }
5293:
5294(
5295 { before(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); }
5296 RightParenthesis
5297 { after(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); }
5298)
5299;
5300finally {
5301 restoreStackSize(stackSize);
5302}
5303
5304
5305rule__ArgumentList__Group_2__0
5306 @init {
5307 int stackSize = keepStackSize();
5308 }
5309:
5310 rule__ArgumentList__Group_2__0__Impl
5311 rule__ArgumentList__Group_2__1
5312;
5313finally {
5314 restoreStackSize(stackSize);
5315}
5316
5317rule__ArgumentList__Group_2__0__Impl
5318 @init {
5319 int stackSize = keepStackSize();
5320 }
5321:
5322(
5323 { before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); }
5324 (rule__ArgumentList__ArgumentsAssignment_2_0)
5325 { after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); }
5326)
5327;
5328finally {
5329 restoreStackSize(stackSize);
5330}
5331
5332rule__ArgumentList__Group_2__1
5333 @init {
5334 int stackSize = keepStackSize();
5335 }
5336:
5337 rule__ArgumentList__Group_2__1__Impl
5338;
5339finally {
5340 restoreStackSize(stackSize);
5341}
5342
5343rule__ArgumentList__Group_2__1__Impl
5344 @init {
5345 int stackSize = keepStackSize();
5346 }
5347:
5348(
5349 { before(grammarAccess.getArgumentListAccess().getGroup_2_1()); }
5350 (rule__ArgumentList__Group_2_1__0)*
5351 { after(grammarAccess.getArgumentListAccess().getGroup_2_1()); }
5352)
5353;
5354finally {
5355 restoreStackSize(stackSize);
5356}
5357
5358
5359rule__ArgumentList__Group_2_1__0
5360 @init {
5361 int stackSize = keepStackSize();
5362 }
5363:
5364 rule__ArgumentList__Group_2_1__0__Impl
5365 rule__ArgumentList__Group_2_1__1
5366;
5367finally {
5368 restoreStackSize(stackSize);
5369}
5370
5371rule__ArgumentList__Group_2_1__0__Impl
5372 @init {
5373 int stackSize = keepStackSize();
5374 }
5375:
5376(
5377 { before(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); }
5378 Comma
5379 { after(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); }
5380)
5381;
5382finally {
5383 restoreStackSize(stackSize);
5384}
5385
5386rule__ArgumentList__Group_2_1__1
5387 @init {
5388 int stackSize = keepStackSize();
5389 }
5390:
5391 rule__ArgumentList__Group_2_1__1__Impl
5392;
5393finally {
5394 restoreStackSize(stackSize);
5395}
5396
5397rule__ArgumentList__Group_2_1__1__Impl
5398 @init {
5399 int stackSize = keepStackSize();
5400 }
5401:
5402(
5403 { before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); }
5404 (rule__ArgumentList__ArgumentsAssignment_2_1_1)
5405 { after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); }
5406)
5407;
5408finally {
5409 restoreStackSize(stackSize);
5410}
5411
5412
5413rule__StarArgument__Group__0
5414 @init {
5415 int stackSize = keepStackSize();
5416 }
5417:
5418 rule__StarArgument__Group__0__Impl
5419 rule__StarArgument__Group__1
5420;
5421finally {
5422 restoreStackSize(stackSize);
5423}
5424
5425rule__StarArgument__Group__0__Impl
5426 @init {
5427 int stackSize = keepStackSize();
5428 }
5429:
5430(
5431 { before(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); }
5432 ()
5433 { after(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); }
5434)
5435;
5436finally {
5437 restoreStackSize(stackSize);
5438}
5439
5440rule__StarArgument__Group__1
5441 @init {
5442 int stackSize = keepStackSize();
5443 }
5444:
5445 rule__StarArgument__Group__1__Impl
5446;
5447finally {
5448 restoreStackSize(stackSize);
5449}
5450
5451rule__StarArgument__Group__1__Impl
5452 @init {
5453 int stackSize = keepStackSize();
5454 }
5455:
5456(
5457 { before(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); }
5458 Asterisk
5459 { after(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); }
5460)
5461;
5462finally {
5463 restoreStackSize(stackSize);
5464}
5465
5466
5467rule__TypedArgument__Group__0
5468 @init {
5469 int stackSize = keepStackSize();
5470 }
5471:
5472 rule__TypedArgument__Group__0__Impl
5473 rule__TypedArgument__Group__1
5474;
5475finally {
5476 restoreStackSize(stackSize);
5477}
5478
5479rule__TypedArgument__Group__0__Impl
5480 @init {
5481 int stackSize = keepStackSize();
5482 }
5483:
5484(
5485 { before(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); }
5486 (rule__TypedArgument__TypeAssignment_0)
5487 { after(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); }
5488)
5489;
5490finally {
5491 restoreStackSize(stackSize);
5492}
5493
5494rule__TypedArgument__Group__1
5495 @init {
5496 int stackSize = keepStackSize();
5497 }
5498:
5499 rule__TypedArgument__Group__1__Impl
5500;
5501finally {
5502 restoreStackSize(stackSize);
5503}
5504
5505rule__TypedArgument__Group__1__Impl
5506 @init {
5507 int stackSize = keepStackSize();
5508 }
5509:
5510(
5511 { before(grammarAccess.getTypedArgumentAccess().getVariableAssignment_1()); }
5512 (rule__TypedArgument__VariableAssignment_1)
5513 { after(grammarAccess.getTypedArgumentAccess().getVariableAssignment_1()); }
5514)
5515;
5516finally {
5517 restoreStackSize(stackSize);
5518}
5519
5520
5521rule__TypedStarArgument__Group__0
5522 @init {
5523 int stackSize = keepStackSize();
5524 }
5525:
5526 rule__TypedStarArgument__Group__0__Impl
5527 rule__TypedStarArgument__Group__1
5528;
5529finally {
5530 restoreStackSize(stackSize);
5531}
5532
5533rule__TypedStarArgument__Group__0__Impl
5534 @init {
5535 int stackSize = keepStackSize();
5536 }
5537:
5538(
5539 { before(grammarAccess.getTypedStarArgumentAccess().getTypeAssignment_0()); }
5540 (rule__TypedStarArgument__TypeAssignment_0)
5541 { after(grammarAccess.getTypedStarArgumentAccess().getTypeAssignment_0()); }
5542)
5543;
5544finally {
5545 restoreStackSize(stackSize);
5546}
5547
5548rule__TypedStarArgument__Group__1
5549 @init {
5550 int stackSize = keepStackSize();
5551 }
5552:
5553 rule__TypedStarArgument__Group__1__Impl
5554;
5555finally {
5556 restoreStackSize(stackSize);
5557}
5558
5559rule__TypedStarArgument__Group__1__Impl
5560 @init {
5561 int stackSize = keepStackSize();
5562 }
5563:
5564(
5565 { before(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); }
5566 Asterisk
5567 { after(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); }
5568)
5569;
5570finally {
5571 restoreStackSize(stackSize);
5572}
5573
5574
5575rule__Interval__Group__0
5576 @init {
5577 int stackSize = keepStackSize();
5578 }
5579:
5580 rule__Interval__Group__0__Impl
5581 rule__Interval__Group__1
5582;
5583finally {
5584 restoreStackSize(stackSize);
5585}
5586
5587rule__Interval__Group__0__Impl
5588 @init {
5589 int stackSize = keepStackSize();
5590 }
5591:
5592(
5593 { before(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); }
5594 LeftSquareBracket
5595 { after(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); }
5596)
5597;
5598finally {
5599 restoreStackSize(stackSize);
5600}
5601
5602rule__Interval__Group__1
5603 @init {
5604 int stackSize = keepStackSize();
5605 }
5606:
5607 rule__Interval__Group__1__Impl
5608 rule__Interval__Group__2
5609;
5610finally {
5611 restoreStackSize(stackSize);
5612}
5613
5614rule__Interval__Group__1__Impl
5615 @init {
5616 int stackSize = keepStackSize();
5617 }
5618:
5619(
5620 { before(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); }
5621 (rule__Interval__LowerBoundAssignment_1)
5622 { after(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); }
5623)
5624;
5625finally {
5626 restoreStackSize(stackSize);
5627}
5628
5629rule__Interval__Group__2
5630 @init {
5631 int stackSize = keepStackSize();
5632 }
5633:
5634 rule__Interval__Group__2__Impl
5635 rule__Interval__Group__3
5636;
5637finally {
5638 restoreStackSize(stackSize);
5639}
5640
5641rule__Interval__Group__2__Impl
5642 @init {
5643 int stackSize = keepStackSize();
5644 }
5645:
5646(
5647 { before(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); }
5648 FullStopFullStop
5649 { after(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); }
5650)
5651;
5652finally {
5653 restoreStackSize(stackSize);
5654}
5655
5656rule__Interval__Group__3
5657 @init {
5658 int stackSize = keepStackSize();
5659 }
5660:
5661 rule__Interval__Group__3__Impl
5662 rule__Interval__Group__4
5663;
5664finally {
5665 restoreStackSize(stackSize);
5666}
5667
5668rule__Interval__Group__3__Impl
5669 @init {
5670 int stackSize = keepStackSize();
5671 }
5672:
5673(
5674 { before(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); }
5675 (rule__Interval__UpperBoundAssignment_3)
5676 { after(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); }
5677)
5678;
5679finally {
5680 restoreStackSize(stackSize);
5681}
5682
5683rule__Interval__Group__4
5684 @init {
5685 int stackSize = keepStackSize();
5686 }
5687:
5688 rule__Interval__Group__4__Impl
5689;
5690finally {
5691 restoreStackSize(stackSize);
5692}
5693
5694rule__Interval__Group__4__Impl
5695 @init {
5696 int stackSize = keepStackSize();
5697 }
5698:
5699(
5700 { before(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); }
5701 RightSquareBracket
5702 { after(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); }
5703)
5704;
5705finally {
5706 restoreStackSize(stackSize);
5707}
5708
5709
5710rule__InfinityLiteral__Group__0
5711 @init {
5712 int stackSize = keepStackSize();
5713 }
5714:
5715 rule__InfinityLiteral__Group__0__Impl
5716 rule__InfinityLiteral__Group__1
5717;
5718finally {
5719 restoreStackSize(stackSize);
5720}
5721
5722rule__InfinityLiteral__Group__0__Impl
5723 @init {
5724 int stackSize = keepStackSize();
5725 }
5726:
5727(
5728 { before(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); }
5729 ()
5730 { after(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); }
5731)
5732;
5733finally {
5734 restoreStackSize(stackSize);
5735}
5736
5737rule__InfinityLiteral__Group__1
5738 @init {
5739 int stackSize = keepStackSize();
5740 }
5741:
5742 rule__InfinityLiteral__Group__1__Impl
5743;
5744finally {
5745 restoreStackSize(stackSize);
5746}
5747
5748rule__InfinityLiteral__Group__1__Impl
5749 @init {
5750 int stackSize = keepStackSize();
5751 }
5752:
5753(
5754 { before(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); }
5755 Inf
5756 { after(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); }
5757)
5758;
5759finally {
5760 restoreStackSize(stackSize);
5761}
5762
5763
5764rule__EmptyIntervalLiteral__Group__0
5765 @init {
5766 int stackSize = keepStackSize();
5767 }
5768:
5769 rule__EmptyIntervalLiteral__Group__0__Impl
5770 rule__EmptyIntervalLiteral__Group__1
5771;
5772finally {
5773 restoreStackSize(stackSize);
5774}
5775
5776rule__EmptyIntervalLiteral__Group__0__Impl
5777 @init {
5778 int stackSize = keepStackSize();
5779 }
5780:
5781(
5782 { before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); }
5783 ()
5784 { after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); }
5785)
5786;
5787finally {
5788 restoreStackSize(stackSize);
5789}
5790
5791rule__EmptyIntervalLiteral__Group__1
5792 @init {
5793 int stackSize = keepStackSize();
5794 }
5795:
5796 rule__EmptyIntervalLiteral__Group__1__Impl
5797;
5798finally {
5799 restoreStackSize(stackSize);
5800}
5801
5802rule__EmptyIntervalLiteral__Group__1__Impl
5803 @init {
5804 int stackSize = keepStackSize();
5805 }
5806:
5807(
5808 { before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); }
5809 Empty
5810 { after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); }
5811)
5812;
5813finally {
5814 restoreStackSize(stackSize);
5815}
5816
5817
5818rule__ClassDefinition__Group__0
5819 @init {
5820 int stackSize = keepStackSize();
5821 }
5822:
5823 rule__ClassDefinition__Group__0__Impl
5824 rule__ClassDefinition__Group__1
5825;
5826finally {
5827 restoreStackSize(stackSize);
5828}
5829
5830rule__ClassDefinition__Group__0__Impl
5831 @init {
5832 int stackSize = keepStackSize();
5833 }
5834:
5835(
5836 { before(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); }
5837 (rule__ClassDefinition__AbstractAssignment_0)?
5838 { after(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); }
5839)
5840;
5841finally {
5842 restoreStackSize(stackSize);
5843}
5844
5845rule__ClassDefinition__Group__1
5846 @init {
5847 int stackSize = keepStackSize();
5848 }
5849:
5850 rule__ClassDefinition__Group__1__Impl
5851 rule__ClassDefinition__Group__2
5852;
5853finally {
5854 restoreStackSize(stackSize);
5855}
5856
5857rule__ClassDefinition__Group__1__Impl
5858 @init {
5859 int stackSize = keepStackSize();
5860 }
5861:
5862(
5863 { before(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); }
5864 Class
5865 { after(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); }
5866)
5867;
5868finally {
5869 restoreStackSize(stackSize);
5870}
5871
5872rule__ClassDefinition__Group__2
5873 @init {
5874 int stackSize = keepStackSize();
5875 }
5876:
5877 rule__ClassDefinition__Group__2__Impl
5878 rule__ClassDefinition__Group__3
5879;
5880finally {
5881 restoreStackSize(stackSize);
5882}
5883
5884rule__ClassDefinition__Group__2__Impl
5885 @init {
5886 int stackSize = keepStackSize();
5887 }
5888:
5889(
5890 { before(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); }
5891 (rule__ClassDefinition__NameAssignment_2)
5892 { after(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); }
5893)
5894;
5895finally {
5896 restoreStackSize(stackSize);
5897}
5898
5899rule__ClassDefinition__Group__3
5900 @init {
5901 int stackSize = keepStackSize();
5902 }
5903:
5904 rule__ClassDefinition__Group__3__Impl
5905 rule__ClassDefinition__Group__4
5906;
5907finally {
5908 restoreStackSize(stackSize);
5909}
5910
5911rule__ClassDefinition__Group__3__Impl
5912 @init {
5913 int stackSize = keepStackSize();
5914 }
5915:
5916(
5917 { before(grammarAccess.getClassDefinitionAccess().getGroup_3()); }
5918 (rule__ClassDefinition__Group_3__0)?
5919 { after(grammarAccess.getClassDefinitionAccess().getGroup_3()); }
5920)
5921;
5922finally {
5923 restoreStackSize(stackSize);
5924}
5925
5926rule__ClassDefinition__Group__4
5927 @init {
5928 int stackSize = keepStackSize();
5929 }
5930:
5931 rule__ClassDefinition__Group__4__Impl
5932 rule__ClassDefinition__Group__5
5933;
5934finally {
5935 restoreStackSize(stackSize);
5936}
5937
5938rule__ClassDefinition__Group__4__Impl
5939 @init {
5940 int stackSize = keepStackSize();
5941 }
5942:
5943(
5944 { before(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); }
5945 LeftCurlyBracket
5946 { after(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); }
5947)
5948;
5949finally {
5950 restoreStackSize(stackSize);
5951}
5952
5953rule__ClassDefinition__Group__5
5954 @init {
5955 int stackSize = keepStackSize();
5956 }
5957:
5958 rule__ClassDefinition__Group__5__Impl
5959 rule__ClassDefinition__Group__6
5960;
5961finally {
5962 restoreStackSize(stackSize);
5963}
5964
5965rule__ClassDefinition__Group__5__Impl
5966 @init {
5967 int stackSize = keepStackSize();
5968 }
5969:
5970(
5971 { before(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); }
5972 (rule__ClassDefinition__MembersAssignment_5)*
5973 { after(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); }
5974)
5975;
5976finally {
5977 restoreStackSize(stackSize);
5978}
5979
5980rule__ClassDefinition__Group__6
5981 @init {
5982 int stackSize = keepStackSize();
5983 }
5984:
5985 rule__ClassDefinition__Group__6__Impl
5986;
5987finally {
5988 restoreStackSize(stackSize);
5989}
5990
5991rule__ClassDefinition__Group__6__Impl
5992 @init {
5993 int stackSize = keepStackSize();
5994 }
5995:
5996(
5997 { before(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); }
5998 RightCurlyBracket
5999 { after(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); }
6000)
6001;
6002finally {
6003 restoreStackSize(stackSize);
6004}
6005
6006
6007rule__ClassDefinition__Group_3__0
6008 @init {
6009 int stackSize = keepStackSize();
6010 }
6011:
6012 rule__ClassDefinition__Group_3__0__Impl
6013 rule__ClassDefinition__Group_3__1
6014;
6015finally {
6016 restoreStackSize(stackSize);
6017}
6018
6019rule__ClassDefinition__Group_3__0__Impl
6020 @init {
6021 int stackSize = keepStackSize();
6022 }
6023:
6024(
6025 { before(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); }
6026 Extends
6027 { after(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); }
6028)
6029;
6030finally {
6031 restoreStackSize(stackSize);
6032}
6033
6034rule__ClassDefinition__Group_3__1
6035 @init {
6036 int stackSize = keepStackSize();
6037 }
6038:
6039 rule__ClassDefinition__Group_3__1__Impl
6040 rule__ClassDefinition__Group_3__2
6041;
6042finally {
6043 restoreStackSize(stackSize);
6044}
6045
6046rule__ClassDefinition__Group_3__1__Impl
6047 @init {
6048 int stackSize = keepStackSize();
6049 }
6050:
6051(
6052 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); }
6053 (rule__ClassDefinition__SuperclassesAssignment_3_1)
6054 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); }
6055)
6056;
6057finally {
6058 restoreStackSize(stackSize);
6059}
6060
6061rule__ClassDefinition__Group_3__2
6062 @init {
6063 int stackSize = keepStackSize();
6064 }
6065:
6066 rule__ClassDefinition__Group_3__2__Impl
6067;
6068finally {
6069 restoreStackSize(stackSize);
6070}
6071
6072rule__ClassDefinition__Group_3__2__Impl
6073 @init {
6074 int stackSize = keepStackSize();
6075 }
6076:
6077(
6078 { before(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); }
6079 (rule__ClassDefinition__Group_3_2__0)*
6080 { after(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); }
6081)
6082;
6083finally {
6084 restoreStackSize(stackSize);
6085}
6086
6087
6088rule__ClassDefinition__Group_3_2__0
6089 @init {
6090 int stackSize = keepStackSize();
6091 }
6092:
6093 rule__ClassDefinition__Group_3_2__0__Impl
6094 rule__ClassDefinition__Group_3_2__1
6095;
6096finally {
6097 restoreStackSize(stackSize);
6098}
6099
6100rule__ClassDefinition__Group_3_2__0__Impl
6101 @init {
6102 int stackSize = keepStackSize();
6103 }
6104:
6105(
6106 { before(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); }
6107 Comma
6108 { after(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); }
6109)
6110;
6111finally {
6112 restoreStackSize(stackSize);
6113}
6114
6115rule__ClassDefinition__Group_3_2__1
6116 @init {
6117 int stackSize = keepStackSize();
6118 }
6119:
6120 rule__ClassDefinition__Group_3_2__1__Impl
6121;
6122finally {
6123 restoreStackSize(stackSize);
6124}
6125
6126rule__ClassDefinition__Group_3_2__1__Impl
6127 @init {
6128 int stackSize = keepStackSize();
6129 }
6130:
6131(
6132 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); }
6133 (rule__ClassDefinition__SuperclassesAssignment_3_2_1)
6134 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); }
6135)
6136;
6137finally {
6138 restoreStackSize(stackSize);
6139}
6140
6141
6142rule__MemberDefinition__Group__0
6143 @init {
6144 int stackSize = keepStackSize();
6145 }
6146:
6147 rule__MemberDefinition__Group__0__Impl
6148 rule__MemberDefinition__Group__1
6149;
6150finally {
6151 restoreStackSize(stackSize);
6152}
6153
6154rule__MemberDefinition__Group__0__Impl
6155 @init {
6156 int stackSize = keepStackSize();
6157 }
6158:
6159(
6160 { before(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); }
6161 (rule__MemberDefinition__ContainmentAssignment_0)?
6162 { after(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); }
6163)
6164;
6165finally {
6166 restoreStackSize(stackSize);
6167}
6168
6169rule__MemberDefinition__Group__1
6170 @init {
6171 int stackSize = keepStackSize();
6172 }
6173:
6174 rule__MemberDefinition__Group__1__Impl
6175 rule__MemberDefinition__Group__2
6176;
6177finally {
6178 restoreStackSize(stackSize);
6179}
6180
6181rule__MemberDefinition__Group__1__Impl
6182 @init {
6183 int stackSize = keepStackSize();
6184 }
6185:
6186(
6187 { before(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); }
6188 (rule__MemberDefinition__TypeAssignment_1)
6189 { after(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); }
6190)
6191;
6192finally {
6193 restoreStackSize(stackSize);
6194}
6195
6196rule__MemberDefinition__Group__2
6197 @init {
6198 int stackSize = keepStackSize();
6199 }
6200:
6201 rule__MemberDefinition__Group__2__Impl
6202 rule__MemberDefinition__Group__3
6203;
6204finally {
6205 restoreStackSize(stackSize);
6206}
6207
6208rule__MemberDefinition__Group__2__Impl
6209 @init {
6210 int stackSize = keepStackSize();
6211 }
6212:
6213(
6214 { before(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); }
6215 (rule__MemberDefinition__MultiplicityAssignment_2)?
6216 { after(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); }
6217)
6218;
6219finally {
6220 restoreStackSize(stackSize);
6221}
6222
6223rule__MemberDefinition__Group__3
6224 @init {
6225 int stackSize = keepStackSize();
6226 }
6227:
6228 rule__MemberDefinition__Group__3__Impl
6229 rule__MemberDefinition__Group__4
6230;
6231finally {
6232 restoreStackSize(stackSize);
6233}
6234
6235rule__MemberDefinition__Group__3__Impl
6236 @init {
6237 int stackSize = keepStackSize();
6238 }
6239:
6240(
6241 { before(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); }
6242 (rule__MemberDefinition__NameAssignment_3)
6243 { after(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); }
6244)
6245;
6246finally {
6247 restoreStackSize(stackSize);
6248}
6249
6250rule__MemberDefinition__Group__4
6251 @init {
6252 int stackSize = keepStackSize();
6253 }
6254:
6255 rule__MemberDefinition__Group__4__Impl
6256 rule__MemberDefinition__Group__5
6257;
6258finally {
6259 restoreStackSize(stackSize);
6260}
6261
6262rule__MemberDefinition__Group__4__Impl
6263 @init {
6264 int stackSize = keepStackSize();
6265 }
6266:
6267(
6268 { before(grammarAccess.getMemberDefinitionAccess().getGroup_4()); }
6269 (rule__MemberDefinition__Group_4__0)?
6270 { after(grammarAccess.getMemberDefinitionAccess().getGroup_4()); }
6271)
6272;
6273finally {
6274 restoreStackSize(stackSize);
6275}
6276
6277rule__MemberDefinition__Group__5
6278 @init {
6279 int stackSize = keepStackSize();
6280 }
6281:
6282 rule__MemberDefinition__Group__5__Impl
6283;
6284finally {
6285 restoreStackSize(stackSize);
6286}
6287
6288rule__MemberDefinition__Group__5__Impl
6289 @init {
6290 int stackSize = keepStackSize();
6291 }
6292:
6293(
6294 { before(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); }
6295 (Semicolon)?
6296 { after(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); }
6297)
6298;
6299finally {
6300 restoreStackSize(stackSize);
6301}
6302
6303
6304rule__MemberDefinition__Group_4__0
6305 @init {
6306 int stackSize = keepStackSize();
6307 }
6308:
6309 rule__MemberDefinition__Group_4__0__Impl
6310 rule__MemberDefinition__Group_4__1
6311;
6312finally {
6313 restoreStackSize(stackSize);
6314}
6315
6316rule__MemberDefinition__Group_4__0__Impl
6317 @init {
6318 int stackSize = keepStackSize();
6319 }
6320:
6321(
6322 { before(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); }
6323 Opposite
6324 { after(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); }
6325)
6326;
6327finally {
6328 restoreStackSize(stackSize);
6329}
6330
6331rule__MemberDefinition__Group_4__1
6332 @init {
6333 int stackSize = keepStackSize();
6334 }
6335:
6336 rule__MemberDefinition__Group_4__1__Impl
6337;
6338finally {
6339 restoreStackSize(stackSize);
6340}
6341
6342rule__MemberDefinition__Group_4__1__Impl
6343 @init {
6344 int stackSize = keepStackSize();
6345 }
6346:
6347(
6348 { before(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); }
6349 (rule__MemberDefinition__OppositeAssignment_4_1)
6350 { after(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); }
6351)
6352;
6353finally {
6354 restoreStackSize(stackSize);
6355}
6356
6357
6358rule__ManyMultiplicity__Group__0
6359 @init {
6360 int stackSize = keepStackSize();
6361 }
6362:
6363 rule__ManyMultiplicity__Group__0__Impl
6364 rule__ManyMultiplicity__Group__1
6365;
6366finally {
6367 restoreStackSize(stackSize);
6368}
6369
6370rule__ManyMultiplicity__Group__0__Impl
6371 @init {
6372 int stackSize = keepStackSize();
6373 }
6374:
6375(
6376 { before(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); }
6377 ()
6378 { after(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); }
6379)
6380;
6381finally {
6382 restoreStackSize(stackSize);
6383}
6384
6385rule__ManyMultiplicity__Group__1
6386 @init {
6387 int stackSize = keepStackSize();
6388 }
6389:
6390 rule__ManyMultiplicity__Group__1__Impl
6391 rule__ManyMultiplicity__Group__2
6392;
6393finally {
6394 restoreStackSize(stackSize);
6395}
6396
6397rule__ManyMultiplicity__Group__1__Impl
6398 @init {
6399 int stackSize = keepStackSize();
6400 }
6401:
6402(
6403 { before(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); }
6404 LeftSquareBracket
6405 { after(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); }
6406)
6407;
6408finally {
6409 restoreStackSize(stackSize);
6410}
6411
6412rule__ManyMultiplicity__Group__2
6413 @init {
6414 int stackSize = keepStackSize();
6415 }
6416:
6417 rule__ManyMultiplicity__Group__2__Impl
6418;
6419finally {
6420 restoreStackSize(stackSize);
6421}
6422
6423rule__ManyMultiplicity__Group__2__Impl
6424 @init {
6425 int stackSize = keepStackSize();
6426 }
6427:
6428(
6429 { before(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); }
6430 RightSquareBracket
6431 { after(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); }
6432)
6433;
6434finally {
6435 restoreStackSize(stackSize);
6436}
6437
6438
6439rule__ExactMultiplicity__Group__0
6440 @init {
6441 int stackSize = keepStackSize();
6442 }
6443:
6444 rule__ExactMultiplicity__Group__0__Impl
6445 rule__ExactMultiplicity__Group__1
6446;
6447finally {
6448 restoreStackSize(stackSize);
6449}
6450
6451rule__ExactMultiplicity__Group__0__Impl
6452 @init {
6453 int stackSize = keepStackSize();
6454 }
6455:
6456(
6457 { before(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
6458 LeftSquareBracket
6459 { after(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
6460)
6461;
6462finally {
6463 restoreStackSize(stackSize);
6464}
6465
6466rule__ExactMultiplicity__Group__1
6467 @init {
6468 int stackSize = keepStackSize();
6469 }
6470:
6471 rule__ExactMultiplicity__Group__1__Impl
6472 rule__ExactMultiplicity__Group__2
6473;
6474finally {
6475 restoreStackSize(stackSize);
6476}
6477
6478rule__ExactMultiplicity__Group__1__Impl
6479 @init {
6480 int stackSize = keepStackSize();
6481 }
6482:
6483(
6484 { before(grammarAccess.getExactMultiplicityAccess().getMultiplicityAssignment_1()); }
6485 (rule__ExactMultiplicity__MultiplicityAssignment_1)
6486 { after(grammarAccess.getExactMultiplicityAccess().getMultiplicityAssignment_1()); }
6487)
6488;
6489finally {
6490 restoreStackSize(stackSize);
6491}
6492
6493rule__ExactMultiplicity__Group__2
6494 @init {
6495 int stackSize = keepStackSize();
6496 }
6497:
6498 rule__ExactMultiplicity__Group__2__Impl
6499;
6500finally {
6501 restoreStackSize(stackSize);
6502}
6503
6504rule__ExactMultiplicity__Group__2__Impl
6505 @init {
6506 int stackSize = keepStackSize();
6507 }
6508:
6509(
6510 { before(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); }
6511 RightSquareBracket
6512 { after(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); }
6513)
6514;
6515finally {
6516 restoreStackSize(stackSize);
6517}
6518
6519
6520rule__BoundedMultiplicity__Group__0
6521 @init {
6522 int stackSize = keepStackSize();
6523 }
6524:
6525 rule__BoundedMultiplicity__Group__0__Impl
6526 rule__BoundedMultiplicity__Group__1
6527;
6528finally {
6529 restoreStackSize(stackSize);
6530}
6531
6532rule__BoundedMultiplicity__Group__0__Impl
6533 @init {
6534 int stackSize = keepStackSize();
6535 }
6536:
6537(
6538 { before(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
6539 LeftSquareBracket
6540 { after(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
6541)
6542;
6543finally {
6544 restoreStackSize(stackSize);
6545}
6546
6547rule__BoundedMultiplicity__Group__1
6548 @init {
6549 int stackSize = keepStackSize();
6550 }
6551:
6552 rule__BoundedMultiplicity__Group__1__Impl
6553 rule__BoundedMultiplicity__Group__2
6554;
6555finally {
6556 restoreStackSize(stackSize);
6557}
6558
6559rule__BoundedMultiplicity__Group__1__Impl
6560 @init {
6561 int stackSize = keepStackSize();
6562 }
6563:
6564(
6565 { before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); }
6566 (rule__BoundedMultiplicity__LowerBoundAssignment_1)
6567 { after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); }
6568)
6569;
6570finally {
6571 restoreStackSize(stackSize);
6572}
6573
6574rule__BoundedMultiplicity__Group__2
6575 @init {
6576 int stackSize = keepStackSize();
6577 }
6578:
6579 rule__BoundedMultiplicity__Group__2__Impl
6580 rule__BoundedMultiplicity__Group__3
6581;
6582finally {
6583 restoreStackSize(stackSize);
6584}
6585
6586rule__BoundedMultiplicity__Group__2__Impl
6587 @init {
6588 int stackSize = keepStackSize();
6589 }
6590:
6591(
6592 { before(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); }
6593 FullStopFullStop
6594 { after(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); }
6595)
6596;
6597finally {
6598 restoreStackSize(stackSize);
6599}
6600
6601rule__BoundedMultiplicity__Group__3
6602 @init {
6603 int stackSize = keepStackSize();
6604 }
6605:
6606 rule__BoundedMultiplicity__Group__3__Impl
6607 rule__BoundedMultiplicity__Group__4
6608;
6609finally {
6610 restoreStackSize(stackSize);
6611}
6612
6613rule__BoundedMultiplicity__Group__3__Impl
6614 @init {
6615 int stackSize = keepStackSize();
6616 }
6617:
6618(
6619 { before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); }
6620 (rule__BoundedMultiplicity__UpperBoundAssignment_3)
6621 { after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); }
6622)
6623;
6624finally {
6625 restoreStackSize(stackSize);
6626}
6627
6628rule__BoundedMultiplicity__Group__4
6629 @init {
6630 int stackSize = keepStackSize();
6631 }
6632:
6633 rule__BoundedMultiplicity__Group__4__Impl
6634;
6635finally {
6636 restoreStackSize(stackSize);
6637}
6638
6639rule__BoundedMultiplicity__Group__4__Impl
6640 @init {
6641 int stackSize = keepStackSize();
6642 }
6643:
6644(
6645 { before(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); }
6646 RightSquareBracket
6647 { after(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); }
6648)
6649;
6650finally {
6651 restoreStackSize(stackSize);
6652}
6653
6654
6655rule__ExactScopeDefinition__Group__0
6656 @init {
6657 int stackSize = keepStackSize();
6658 }
6659:
6660 rule__ExactScopeDefinition__Group__0__Impl
6661 rule__ExactScopeDefinition__Group__1
6662;
6663finally {
6664 restoreStackSize(stackSize);
6665}
6666
6667rule__ExactScopeDefinition__Group__0__Impl
6668 @init {
6669 int stackSize = keepStackSize();
6670 }
6671:
6672(
6673 { before(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); }
6674 Scope
6675 { after(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); }
6676)
6677;
6678finally {
6679 restoreStackSize(stackSize);
6680}
6681
6682rule__ExactScopeDefinition__Group__1
6683 @init {
6684 int stackSize = keepStackSize();
6685 }
6686:
6687 rule__ExactScopeDefinition__Group__1__Impl
6688 rule__ExactScopeDefinition__Group__2
6689;
6690finally {
6691 restoreStackSize(stackSize);
6692}
6693
6694rule__ExactScopeDefinition__Group__1__Impl
6695 @init {
6696 int stackSize = keepStackSize();
6697 }
6698:
6699(
6700 { before(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); }
6701 (rule__ExactScopeDefinition__TypeAssignment_1)
6702 { after(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); }
6703)
6704;
6705finally {
6706 restoreStackSize(stackSize);
6707}
6708
6709rule__ExactScopeDefinition__Group__2
6710 @init {
6711 int stackSize = keepStackSize();
6712 }
6713:
6714 rule__ExactScopeDefinition__Group__2__Impl
6715 rule__ExactScopeDefinition__Group__3
6716;
6717finally {
6718 restoreStackSize(stackSize);
6719}
6720
6721rule__ExactScopeDefinition__Group__2__Impl
6722 @init {
6723 int stackSize = keepStackSize();
6724 }
6725:
6726(
6727 { before(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); }
6728 EqualsSignEqualsSign
6729 { after(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); }
6730)
6731;
6732finally {
6733 restoreStackSize(stackSize);
6734}
6735
6736rule__ExactScopeDefinition__Group__3
6737 @init {
6738 int stackSize = keepStackSize();
6739 }
6740:
6741 rule__ExactScopeDefinition__Group__3__Impl
6742;
6743finally {
6744 restoreStackSize(stackSize);
6745}
6746
6747rule__ExactScopeDefinition__Group__3__Impl
6748 @init {
6749 int stackSize = keepStackSize();
6750 }
6751:
6752(
6753 { before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); }
6754 (rule__ExactScopeDefinition__ExactScopeAssignment_3)
6755 { after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); }
6756)
6757;
6758finally {
6759 restoreStackSize(stackSize);
6760}
6761
6762
6763rule__BoundedScopeDefinition__Group__0
6764 @init {
6765 int stackSize = keepStackSize();
6766 }
6767:
6768 rule__BoundedScopeDefinition__Group__0__Impl
6769 rule__BoundedScopeDefinition__Group__1
6770;
6771finally {
6772 restoreStackSize(stackSize);
6773}
6774
6775rule__BoundedScopeDefinition__Group__0__Impl
6776 @init {
6777 int stackSize = keepStackSize();
6778 }
6779:
6780(
6781 { before(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); }
6782 Scope
6783 { after(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); }
6784)
6785;
6786finally {
6787 restoreStackSize(stackSize);
6788}
6789
6790rule__BoundedScopeDefinition__Group__1
6791 @init {
6792 int stackSize = keepStackSize();
6793 }
6794:
6795 rule__BoundedScopeDefinition__Group__1__Impl
6796;
6797finally {
6798 restoreStackSize(stackSize);
6799}
6800
6801rule__BoundedScopeDefinition__Group__1__Impl
6802 @init {
6803 int stackSize = keepStackSize();
6804 }
6805:
6806(
6807 { before(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); }
6808 (rule__BoundedScopeDefinition__Alternatives_1)
6809 { after(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); }
6810)
6811;
6812finally {
6813 restoreStackSize(stackSize);
6814}
6815
6816
6817rule__BoundedScopeDefinition__Group_1_0__0
6818 @init {
6819 int stackSize = keepStackSize();
6820 }
6821:
6822 rule__BoundedScopeDefinition__Group_1_0__0__Impl
6823 rule__BoundedScopeDefinition__Group_1_0__1
6824;
6825finally {
6826 restoreStackSize(stackSize);
6827}
6828
6829rule__BoundedScopeDefinition__Group_1_0__0__Impl
6830 @init {
6831 int stackSize = keepStackSize();
6832 }
6833:
6834(
6835 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); }
6836 (rule__BoundedScopeDefinition__Group_1_0_0__0)?
6837 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); }
6838)
6839;
6840finally {
6841 restoreStackSize(stackSize);
6842}
6843
6844rule__BoundedScopeDefinition__Group_1_0__1
6845 @init {
6846 int stackSize = keepStackSize();
6847 }
6848:
6849 rule__BoundedScopeDefinition__Group_1_0__1__Impl
6850 rule__BoundedScopeDefinition__Group_1_0__2
6851;
6852finally {
6853 restoreStackSize(stackSize);
6854}
6855
6856rule__BoundedScopeDefinition__Group_1_0__1__Impl
6857 @init {
6858 int stackSize = keepStackSize();
6859 }
6860:
6861(
6862 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); }
6863 (rule__BoundedScopeDefinition__TypeAssignment_1_0_1)
6864 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); }
6865)
6866;
6867finally {
6868 restoreStackSize(stackSize);
6869}
6870
6871rule__BoundedScopeDefinition__Group_1_0__2
6872 @init {
6873 int stackSize = keepStackSize();
6874 }
6875:
6876 rule__BoundedScopeDefinition__Group_1_0__2__Impl
6877 rule__BoundedScopeDefinition__Group_1_0__3
6878;
6879finally {
6880 restoreStackSize(stackSize);
6881}
6882
6883rule__BoundedScopeDefinition__Group_1_0__2__Impl
6884 @init {
6885 int stackSize = keepStackSize();
6886 }
6887:
6888(
6889 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); }
6890 LessThanSignEqualsSign
6891 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); }
6892)
6893;
6894finally {
6895 restoreStackSize(stackSize);
6896}
6897
6898rule__BoundedScopeDefinition__Group_1_0__3
6899 @init {
6900 int stackSize = keepStackSize();
6901 }
6902:
6903 rule__BoundedScopeDefinition__Group_1_0__3__Impl
6904;
6905finally {
6906 restoreStackSize(stackSize);
6907}
6908
6909rule__BoundedScopeDefinition__Group_1_0__3__Impl
6910 @init {
6911 int stackSize = keepStackSize();
6912 }
6913:
6914(
6915 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); }
6916 (rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3)
6917 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); }
6918)
6919;
6920finally {
6921 restoreStackSize(stackSize);
6922}
6923
6924
6925rule__BoundedScopeDefinition__Group_1_0_0__0
6926 @init {
6927 int stackSize = keepStackSize();
6928 }
6929:
6930 rule__BoundedScopeDefinition__Group_1_0_0__0__Impl
6931 rule__BoundedScopeDefinition__Group_1_0_0__1
6932;
6933finally {
6934 restoreStackSize(stackSize);
6935}
6936
6937rule__BoundedScopeDefinition__Group_1_0_0__0__Impl
6938 @init {
6939 int stackSize = keepStackSize();
6940 }
6941:
6942(
6943 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); }
6944 (rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0)
6945 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); }
6946)
6947;
6948finally {
6949 restoreStackSize(stackSize);
6950}
6951
6952rule__BoundedScopeDefinition__Group_1_0_0__1
6953 @init {
6954 int stackSize = keepStackSize();
6955 }
6956:
6957 rule__BoundedScopeDefinition__Group_1_0_0__1__Impl
6958;
6959finally {
6960 restoreStackSize(stackSize);
6961}
6962
6963rule__BoundedScopeDefinition__Group_1_0_0__1__Impl
6964 @init {
6965 int stackSize = keepStackSize();
6966 }
6967:
6968(
6969 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); }
6970 LessThanSignEqualsSign
6971 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); }
6972)
6973;
6974finally {
6975 restoreStackSize(stackSize);
6976}
6977
6978
6979rule__BoundedScopeDefinition__Group_1_1__0
6980 @init {
6981 int stackSize = keepStackSize();
6982 }
6983:
6984 rule__BoundedScopeDefinition__Group_1_1__0__Impl
6985 rule__BoundedScopeDefinition__Group_1_1__1
6986;
6987finally {
6988 restoreStackSize(stackSize);
6989}
6990
6991rule__BoundedScopeDefinition__Group_1_1__0__Impl
6992 @init {
6993 int stackSize = keepStackSize();
6994 }
6995:
6996(
6997 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); }
6998 (rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0)
6999 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); }
7000)
7001;
7002finally {
7003 restoreStackSize(stackSize);
7004}
7005
7006rule__BoundedScopeDefinition__Group_1_1__1
7007 @init {
7008 int stackSize = keepStackSize();
7009 }
7010:
7011 rule__BoundedScopeDefinition__Group_1_1__1__Impl
7012 rule__BoundedScopeDefinition__Group_1_1__2
7013;
7014finally {
7015 restoreStackSize(stackSize);
7016}
7017
7018rule__BoundedScopeDefinition__Group_1_1__1__Impl
7019 @init {
7020 int stackSize = keepStackSize();
7021 }
7022:
7023(
7024 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
7025 GreaterThanSignEqualsSign
7026 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
7027)
7028;
7029finally {
7030 restoreStackSize(stackSize);
7031}
7032
7033rule__BoundedScopeDefinition__Group_1_1__2
7034 @init {
7035 int stackSize = keepStackSize();
7036 }
7037:
7038 rule__BoundedScopeDefinition__Group_1_1__2__Impl
7039 rule__BoundedScopeDefinition__Group_1_1__3
7040;
7041finally {
7042 restoreStackSize(stackSize);
7043}
7044
7045rule__BoundedScopeDefinition__Group_1_1__2__Impl
7046 @init {
7047 int stackSize = keepStackSize();
7048 }
7049:
7050(
7051 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); }
7052 (rule__BoundedScopeDefinition__TypeAssignment_1_1_2)
7053 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); }
7054)
7055;
7056finally {
7057 restoreStackSize(stackSize);
7058}
7059
7060rule__BoundedScopeDefinition__Group_1_1__3
7061 @init {
7062 int stackSize = keepStackSize();
7063 }
7064:
7065 rule__BoundedScopeDefinition__Group_1_1__3__Impl
7066;
7067finally {
7068 restoreStackSize(stackSize);
7069}
7070
7071rule__BoundedScopeDefinition__Group_1_1__3__Impl
7072 @init {
7073 int stackSize = keepStackSize();
7074 }
7075:
7076(
7077 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); }
7078 (rule__BoundedScopeDefinition__Group_1_1_3__0)?
7079 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); }
7080)
7081;
7082finally {
7083 restoreStackSize(stackSize);
7084}
7085
7086
7087rule__BoundedScopeDefinition__Group_1_1_3__0
7088 @init {
7089 int stackSize = keepStackSize();
7090 }
7091:
7092 rule__BoundedScopeDefinition__Group_1_1_3__0__Impl
7093 rule__BoundedScopeDefinition__Group_1_1_3__1
7094;
7095finally {
7096 restoreStackSize(stackSize);
7097}
7098
7099rule__BoundedScopeDefinition__Group_1_1_3__0__Impl
7100 @init {
7101 int stackSize = keepStackSize();
7102 }
7103:
7104(
7105 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); }
7106 GreaterThanSignEqualsSign
7107 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); }
7108)
7109;
7110finally {
7111 restoreStackSize(stackSize);
7112}
7113
7114rule__BoundedScopeDefinition__Group_1_1_3__1
7115 @init {
7116 int stackSize = keepStackSize();
7117 }
7118:
7119 rule__BoundedScopeDefinition__Group_1_1_3__1__Impl
7120;
7121finally {
7122 restoreStackSize(stackSize);
7123}
7124
7125rule__BoundedScopeDefinition__Group_1_1_3__1__Impl
7126 @init {
7127 int stackSize = keepStackSize();
7128 }
7129:
7130(
7131 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); }
7132 (rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1)
7133 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); }
7134)
7135;
7136finally {
7137 restoreStackSize(stackSize);
7138}
7139
7140
7141rule__LowerBoundedScopeDefinition__Group__0
7142 @init {
7143 int stackSize = keepStackSize();
7144 }
7145:
7146 rule__LowerBoundedScopeDefinition__Group__0__Impl
7147 rule__LowerBoundedScopeDefinition__Group__1
7148;
7149finally {
7150 restoreStackSize(stackSize);
7151}
7152
7153rule__LowerBoundedScopeDefinition__Group__0__Impl
7154 @init {
7155 int stackSize = keepStackSize();
7156 }
7157:
7158(
7159 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); }
7160 Scope
7161 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); }
7162)
7163;
7164finally {
7165 restoreStackSize(stackSize);
7166}
7167
7168rule__LowerBoundedScopeDefinition__Group__1
7169 @init {
7170 int stackSize = keepStackSize();
7171 }
7172:
7173 rule__LowerBoundedScopeDefinition__Group__1__Impl
7174;
7175finally {
7176 restoreStackSize(stackSize);
7177}
7178
7179rule__LowerBoundedScopeDefinition__Group__1__Impl
7180 @init {
7181 int stackSize = keepStackSize();
7182 }
7183:
7184(
7185 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); }
7186 (rule__LowerBoundedScopeDefinition__Alternatives_1)
7187 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); }
7188)
7189;
7190finally {
7191 restoreStackSize(stackSize);
7192}
7193
7194
7195rule__LowerBoundedScopeDefinition__Group_1_0__0
7196 @init {
7197 int stackSize = keepStackSize();
7198 }
7199:
7200 rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl
7201 rule__LowerBoundedScopeDefinition__Group_1_0__1
7202;
7203finally {
7204 restoreStackSize(stackSize);
7205}
7206
7207rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl
7208 @init {
7209 int stackSize = keepStackSize();
7210 }
7211:
7212(
7213 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); }
7214 (rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0)
7215 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); }
7216)
7217;
7218finally {
7219 restoreStackSize(stackSize);
7220}
7221
7222rule__LowerBoundedScopeDefinition__Group_1_0__1
7223 @init {
7224 int stackSize = keepStackSize();
7225 }
7226:
7227 rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl
7228 rule__LowerBoundedScopeDefinition__Group_1_0__2
7229;
7230finally {
7231 restoreStackSize(stackSize);
7232}
7233
7234rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl
7235 @init {
7236 int stackSize = keepStackSize();
7237 }
7238:
7239(
7240 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); }
7241 LessThanSignEqualsSign
7242 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); }
7243)
7244;
7245finally {
7246 restoreStackSize(stackSize);
7247}
7248
7249rule__LowerBoundedScopeDefinition__Group_1_0__2
7250 @init {
7251 int stackSize = keepStackSize();
7252 }
7253:
7254 rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl
7255;
7256finally {
7257 restoreStackSize(stackSize);
7258}
7259
7260rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl
7261 @init {
7262 int stackSize = keepStackSize();
7263 }
7264:
7265(
7266 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); }
7267 (rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2)
7268 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); }
7269)
7270;
7271finally {
7272 restoreStackSize(stackSize);
7273}
7274
7275
7276rule__LowerBoundedScopeDefinition__Group_1_1__0
7277 @init {
7278 int stackSize = keepStackSize();
7279 }
7280:
7281 rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl
7282 rule__LowerBoundedScopeDefinition__Group_1_1__1
7283;
7284finally {
7285 restoreStackSize(stackSize);
7286}
7287
7288rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl
7289 @init {
7290 int stackSize = keepStackSize();
7291 }
7292:
7293(
7294 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); }
7295 (rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0)
7296 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); }
7297)
7298;
7299finally {
7300 restoreStackSize(stackSize);
7301}
7302
7303rule__LowerBoundedScopeDefinition__Group_1_1__1
7304 @init {
7305 int stackSize = keepStackSize();
7306 }
7307:
7308 rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl
7309 rule__LowerBoundedScopeDefinition__Group_1_1__2
7310;
7311finally {
7312 restoreStackSize(stackSize);
7313}
7314
7315rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl
7316 @init {
7317 int stackSize = keepStackSize();
7318 }
7319:
7320(
7321 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
7322 GreaterThanSignEqualsSign
7323 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
7324)
7325;
7326finally {
7327 restoreStackSize(stackSize);
7328}
7329
7330rule__LowerBoundedScopeDefinition__Group_1_1__2
7331 @init {
7332 int stackSize = keepStackSize();
7333 }
7334:
7335 rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl
7336;
7337finally {
7338 restoreStackSize(stackSize);
7339}
7340
7341rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl
7342 @init {
7343 int stackSize = keepStackSize();
7344 }
7345:
7346(
7347 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); }
7348 (rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2)
7349 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); }
7350)
7351;
7352finally {
7353 restoreStackSize(stackSize);
7354}
7355
7356
7357rule__ObjectiveDefinition__Group__0
7358 @init {
7359 int stackSize = keepStackSize();
7360 }
7361:
7362 rule__ObjectiveDefinition__Group__0__Impl
7363 rule__ObjectiveDefinition__Group__1
7364;
7365finally {
7366 restoreStackSize(stackSize);
7367}
7368
7369rule__ObjectiveDefinition__Group__0__Impl
7370 @init {
7371 int stackSize = keepStackSize();
7372 }
7373:
7374(
7375 { before(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); }
7376 (rule__ObjectiveDefinition__KindAssignment_0)
7377 { after(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); }
7378)
7379;
7380finally {
7381 restoreStackSize(stackSize);
7382}
7383
7384rule__ObjectiveDefinition__Group__1
7385 @init {
7386 int stackSize = keepStackSize();
7387 }
7388:
7389 rule__ObjectiveDefinition__Group__1__Impl
7390;
7391finally {
7392 restoreStackSize(stackSize);
7393}
7394
7395rule__ObjectiveDefinition__Group__1__Impl
7396 @init {
7397 int stackSize = keepStackSize();
7398 }
7399:
7400(
7401 { before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); }
7402 (rule__ObjectiveDefinition__ObjectiveAssignment_1)
7403 { after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); }
7404)
7405;
7406finally {
7407 restoreStackSize(stackSize);
7408}
7409
7410
7411rule__Real__Group__0
7412 @init {
7413 int stackSize = keepStackSize();
7414 }
7415:
7416 rule__Real__Group__0__Impl
7417 rule__Real__Group__1
7418;
7419finally {
7420 restoreStackSize(stackSize);
7421}
7422
7423rule__Real__Group__0__Impl
7424 @init {
7425 int stackSize = keepStackSize();
7426 }
7427:
7428(
7429 { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); }
7430 RULE_INT
7431 { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); }
7432)
7433;
7434finally {
7435 restoreStackSize(stackSize);
7436}
7437
7438rule__Real__Group__1
7439 @init {
7440 int stackSize = keepStackSize();
7441 }
7442:
7443 rule__Real__Group__1__Impl
7444;
7445finally {
7446 restoreStackSize(stackSize);
7447}
7448
7449rule__Real__Group__1__Impl
7450 @init {
7451 int stackSize = keepStackSize();
7452 }
7453:
7454(
7455 { before(grammarAccess.getRealAccess().getGroup_1()); }
7456 (rule__Real__Group_1__0)?
7457 { after(grammarAccess.getRealAccess().getGroup_1()); }
7458)
7459;
7460finally {
7461 restoreStackSize(stackSize);
7462}
7463
7464
7465rule__Real__Group_1__0
7466 @init {
7467 int stackSize = keepStackSize();
7468 }
7469:
7470 rule__Real__Group_1__0__Impl
7471 rule__Real__Group_1__1
7472;
7473finally {
7474 restoreStackSize(stackSize);
7475}
7476
7477rule__Real__Group_1__0__Impl
7478 @init {
7479 int stackSize = keepStackSize();
7480 }
7481:
7482(
7483 { before(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); }
7484 FullStop
7485 { after(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); }
7486)
7487;
7488finally {
7489 restoreStackSize(stackSize);
7490}
7491
7492rule__Real__Group_1__1
7493 @init {
7494 int stackSize = keepStackSize();
7495 }
7496:
7497 rule__Real__Group_1__1__Impl
7498;
7499finally {
7500 restoreStackSize(stackSize);
7501}
7502
7503rule__Real__Group_1__1__Impl
7504 @init {
7505 int stackSize = keepStackSize();
7506 }
7507:
7508(
7509 { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); }
7510 RULE_INT
7511 { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); }
7512)
7513;
7514finally {
7515 restoreStackSize(stackSize);
7516}
7517
7518
7519rule__QualifiedName__Group_0__0
7520 @init {
7521 int stackSize = keepStackSize();
7522 }
7523:
7524 rule__QualifiedName__Group_0__0__Impl
7525 rule__QualifiedName__Group_0__1
7526;
7527finally {
7528 restoreStackSize(stackSize);
7529}
7530
7531rule__QualifiedName__Group_0__0__Impl
7532 @init {
7533 int stackSize = keepStackSize();
7534 }
7535:
7536(
7537 { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); }
7538 RULE_ID
7539 { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); }
7540)
7541;
7542finally {
7543 restoreStackSize(stackSize);
7544}
7545
7546rule__QualifiedName__Group_0__1
7547 @init {
7548 int stackSize = keepStackSize();
7549 }
7550:
7551 rule__QualifiedName__Group_0__1__Impl
7552;
7553finally {
7554 restoreStackSize(stackSize);
7555}
7556
7557rule__QualifiedName__Group_0__1__Impl
7558 @init {
7559 int stackSize = keepStackSize();
7560 }
7561:
7562(
7563 { before(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); }
7564 (rule__QualifiedName__Group_0_1__0)*
7565 { after(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); }
7566)
7567;
7568finally {
7569 restoreStackSize(stackSize);
7570}
7571
7572
7573rule__QualifiedName__Group_0_1__0
7574 @init {
7575 int stackSize = keepStackSize();
7576 }
7577:
7578 rule__QualifiedName__Group_0_1__0__Impl
7579 rule__QualifiedName__Group_0_1__1
7580;
7581finally {
7582 restoreStackSize(stackSize);
7583}
7584
7585rule__QualifiedName__Group_0_1__0__Impl
7586 @init {
7587 int stackSize = keepStackSize();
7588 }
7589:
7590(
7591 { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); }
7592 FullStop
7593 { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); }
7594)
7595;
7596finally {
7597 restoreStackSize(stackSize);
7598}
7599
7600rule__QualifiedName__Group_0_1__1
7601 @init {
7602 int stackSize = keepStackSize();
7603 }
7604:
7605 rule__QualifiedName__Group_0_1__1__Impl
7606;
7607finally {
7608 restoreStackSize(stackSize);
7609}
7610
7611rule__QualifiedName__Group_0_1__1__Impl
7612 @init {
7613 int stackSize = keepStackSize();
7614 }
7615:
7616(
7617 { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); }
7618 RULE_ID
7619 { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); }
7620)
7621;
7622finally {
7623 restoreStackSize(stackSize);
7624}
7625
7626
7627rule__Problem__StatementsAssignment
7628 @init {
7629 int stackSize = keepStackSize();
7630 }
7631:
7632 (
7633 { before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); }
7634 ruleStatement
7635 { after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); }
7636 )
7637;
7638finally {
7639 restoreStackSize(stackSize);
7640}
7641
7642rule__AssertionOrDefinition__RangeAssignment_1_0_1_1
7643 @init {
7644 int stackSize = keepStackSize();
7645 }
7646:
7647 (
7648 { before(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); }
7649 ruleExpression
7650 { after(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); }
7651 )
7652;
7653finally {
7654 restoreStackSize(stackSize);
7655}
7656
7657rule__AssertionOrDefinition__BodyAssignment_1_1_2
7658 @init {
7659 int stackSize = keepStackSize();
7660 }
7661:
7662 (
7663 { before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); }
7664 ruleExpression
7665 { after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); }
7666 )
7667;
7668finally {
7669 restoreStackSize(stackSize);
7670}
7671
7672rule__AssertionOrDefinition__BodyAssignment_1_2_2
7673 @init {
7674 int stackSize = keepStackSize();
7675 }
7676:
7677 (
7678 { before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); }
7679 ruleExpression
7680 { after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); }
7681 )
7682;
7683finally {
7684 restoreStackSize(stackSize);
7685}
7686
7687rule__PredicateDefinition__FunctionalAssignment_0_0_0
7688 @init {
7689 int stackSize = keepStackSize();
7690 }
7691:
7692 (
7693 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
7694 (
7695 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
7696 Functional
7697 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
7698 )
7699 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
7700 )
7701;
7702finally {
7703 restoreStackSize(stackSize);
7704}
7705
7706rule__PredicateDefinition__ErrorAssignment_0_0_1
7707 @init {
7708 int stackSize = keepStackSize();
7709 }
7710:
7711 (
7712 { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
7713 (
7714 { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
7715 Error
7716 { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
7717 )
7718 { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
7719 )
7720;
7721finally {
7722 restoreStackSize(stackSize);
7723}
7724
7725rule__PredicateDefinition__ErrorAssignment_0_1_0
7726 @init {
7727 int stackSize = keepStackSize();
7728 }
7729:
7730 (
7731 { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
7732 (
7733 { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
7734 Error
7735 { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
7736 )
7737 { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
7738 )
7739;
7740finally {
7741 restoreStackSize(stackSize);
7742}
7743
7744rule__PredicateDefinition__FunctionalAssignment_0_1_1
7745 @init {
7746 int stackSize = keepStackSize();
7747 }
7748:
7749 (
7750 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
7751 (
7752 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
7753 Functional
7754 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
7755 )
7756 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
7757 )
7758;
7759finally {
7760 restoreStackSize(stackSize);
7761}
7762
7763rule__PredicateDefinition__HeadAssignment_1
7764 @init {
7765 int stackSize = keepStackSize();
7766 }
7767:
7768 (
7769 { before(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
7770 ruleCall
7771 { after(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
7772 )
7773;
7774finally {
7775 restoreStackSize(stackSize);
7776}
7777
7778rule__PredicateDefinition__BodyAssignment_3
7779 @init {
7780 int stackSize = keepStackSize();
7781 }
7782:
7783 (
7784 { before(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
7785 ruleExpression
7786 { after(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
7787 )
7788;
7789finally {
7790 restoreStackSize(stackSize);
7791}
7792
7793rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1
7794 @init {
7795 int stackSize = keepStackSize();
7796 }
7797:
7798 (
7799 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
7800 ruleArgumentList
7801 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
7802 )
7803;
7804finally {
7805 restoreStackSize(stackSize);
7806}
7807
7808rule__UnnamedErrorPrediateDefinition__BodyAssignment_3
7809 @init {
7810 int stackSize = keepStackSize();
7811 }
7812:
7813 (
7814 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
7815 ruleExpression
7816 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
7817 )
7818;
7819finally {
7820 restoreStackSize(stackSize);
7821}
7822
7823rule__DefaultDefinition__HeadAssignment_1
7824 @init {
7825 int stackSize = keepStackSize();
7826 }
7827:
7828 (
7829 { before(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
7830 ruleCall
7831 { after(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
7832 )
7833;
7834finally {
7835 restoreStackSize(stackSize);
7836}
7837
7838rule__DefaultDefinition__RangeAssignment_3
7839 @init {
7840 int stackSize = keepStackSize();
7841 }
7842:
7843 (
7844 { before(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); }
7845 ruleExpression
7846 { after(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); }
7847 )
7848;
7849finally {
7850 restoreStackSize(stackSize);
7851}
7852
7853rule__ExternPredicateDefinition__HeadAssignment_1
7854 @init {
7855 int stackSize = keepStackSize();
7856 }
7857:
7858 (
7859 { before(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
7860 ruleCall
7861 { after(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
7862 )
7863;
7864finally {
7865 restoreStackSize(stackSize);
7866}
7867
7868rule__MetricDefinition__TypeAssignment_0
7869 @init {
7870 int stackSize = keepStackSize();
7871 }
7872:
7873 (
7874 { before(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); }
7875 ruleMetricType
7876 { after(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); }
7877 )
7878;
7879finally {
7880 restoreStackSize(stackSize);
7881}
7882
7883rule__MetricDefinition__HeadAssignment_1
7884 @init {
7885 int stackSize = keepStackSize();
7886 }
7887:
7888 (
7889 { before(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); }
7890 ruleExpression
7891 { after(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); }
7892 )
7893;
7894finally {
7895 restoreStackSize(stackSize);
7896}
7897
7898rule__MetricDefinition__BodyAssignment_3
7899 @init {
7900 int stackSize = keepStackSize();
7901 }
7902:
7903 (
7904 { before(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
7905 ruleExpression
7906 { after(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
7907 )
7908;
7909finally {
7910 restoreStackSize(stackSize);
7911}
7912
7913rule__ExternMetricDefinition__TypeAssignment_1
7914 @init {
7915 int stackSize = keepStackSize();
7916 }
7917:
7918 (
7919 { before(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); }
7920 ruleMetricType
7921 { after(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); }
7922 )
7923;
7924finally {
7925 restoreStackSize(stackSize);
7926}
7927
7928rule__ExternMetricDefinition__HeadAssignment_2
7929 @init {
7930 int stackSize = keepStackSize();
7931 }
7932:
7933 (
7934 { before(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); }
7935 ruleCall
7936 { after(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); }
7937 )
7938;
7939finally {
7940 restoreStackSize(stackSize);
7941}
7942
7943rule__IfElse__ConditionAssignment_1
7944 @init {
7945 int stackSize = keepStackSize();
7946 }
7947:
7948 (
7949 { before(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); }
7950 ruleExpression
7951 { after(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); }
7952 )
7953;
7954finally {
7955 restoreStackSize(stackSize);
7956}
7957
7958rule__IfElse__ThenAssignment_3
7959 @init {
7960 int stackSize = keepStackSize();
7961 }
7962:
7963 (
7964 { before(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); }
7965 ruleExpression
7966 { after(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); }
7967 )
7968;
7969finally {
7970 restoreStackSize(stackSize);
7971}
7972
7973rule__IfElse__ElseAssignment_5
7974 @init {
7975 int stackSize = keepStackSize();
7976 }
7977:
7978 (
7979 { before(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); }
7980 ruleExpression
7981 { after(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); }
7982 )
7983;
7984finally {
7985 restoreStackSize(stackSize);
7986}
7987
7988rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1
7989 @init {
7990 int stackSize = keepStackSize();
7991 }
7992:
7993 (
7994 { before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); }
7995 ruleConjunctiveExpression
7996 { after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); }
7997 )
7998;
7999finally {
8000 restoreStackSize(stackSize);
8001}
8002
8003rule__DisjunctiveExpression__BodyAssignment_1_1_2
8004 @init {
8005 int stackSize = keepStackSize();
8006 }
8007:
8008 (
8009 { before(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); }
8010 ruleConjunctiveExpression
8011 { after(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); }
8012 )
8013;
8014finally {
8015 restoreStackSize(stackSize);
8016}
8017
8018rule__DisjunctiveExpression__CasesAssignment_1_1_4_1
8019 @init {
8020 int stackSize = keepStackSize();
8021 }
8022:
8023 (
8024 { before(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); }
8025 ruleCase
8026 { after(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); }
8027 )
8028;
8029finally {
8030 restoreStackSize(stackSize);
8031}
8032
8033rule__Case__ConditionAssignment_0
8034 @init {
8035 int stackSize = keepStackSize();
8036 }
8037:
8038 (
8039 { before(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); }
8040 ruleConjunctiveExpression
8041 { after(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); }
8042 )
8043;
8044finally {
8045 restoreStackSize(stackSize);
8046}
8047
8048rule__Case__BodyAssignment_2
8049 @init {
8050 int stackSize = keepStackSize();
8051 }
8052:
8053 (
8054 { before(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); }
8055 ruleConjunctiveExpression
8056 { after(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); }
8057 )
8058;
8059finally {
8060 restoreStackSize(stackSize);
8061}
8062
8063rule__ConjunctiveExpression__ChildrenAssignment_1_1_1
8064 @init {
8065 int stackSize = keepStackSize();
8066 }
8067:
8068 (
8069 { before(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); }
8070 ruleComparisonExpression
8071 { after(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); }
8072 )
8073;
8074finally {
8075 restoreStackSize(stackSize);
8076}
8077
8078rule__ComparisonExpression__OpAssignment_1_1
8079 @init {
8080 int stackSize = keepStackSize();
8081 }
8082:
8083 (
8084 { before(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); }
8085 ruleComparisonOperator
8086 { after(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); }
8087 )
8088;
8089finally {
8090 restoreStackSize(stackSize);
8091}
8092
8093rule__ComparisonExpression__RightAssignment_1_2
8094 @init {
8095 int stackSize = keepStackSize();
8096 }
8097:
8098 (
8099 { before(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); }
8100 ruleAdditiveExpression
8101 { after(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); }
8102 )
8103;
8104finally {
8105 restoreStackSize(stackSize);
8106}
8107
8108rule__AdditiveExpression__OpAssignment_1_1
8109 @init {
8110 int stackSize = keepStackSize();
8111 }
8112:
8113 (
8114 { before(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); }
8115 ruleAdditiveBinaryOperator
8116 { after(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); }
8117 )
8118;
8119finally {
8120 restoreStackSize(stackSize);
8121}
8122
8123rule__AdditiveExpression__RightAssignment_1_2
8124 @init {
8125 int stackSize = keepStackSize();
8126 }
8127:
8128 (
8129 { before(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); }
8130 ruleMultiplicativeExpression
8131 { after(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); }
8132 )
8133;
8134finally {
8135 restoreStackSize(stackSize);
8136}
8137
8138rule__MultiplicativeExpression__OpAssignment_1_1
8139 @init {
8140 int stackSize = keepStackSize();
8141 }
8142:
8143 (
8144 { before(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); }
8145 ruleMultiplicativeBinaryOperator
8146 { after(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); }
8147 )
8148;
8149finally {
8150 restoreStackSize(stackSize);
8151}
8152
8153rule__MultiplicativeExpression__RightAssignment_1_2
8154 @init {
8155 int stackSize = keepStackSize();
8156 }
8157:
8158 (
8159 { before(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); }
8160 ruleExponentialExpression
8161 { after(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); }
8162 )
8163;
8164finally {
8165 restoreStackSize(stackSize);
8166}
8167
8168rule__ExponentialExpression__OpAssignment_1_1
8169 @init {
8170 int stackSize = keepStackSize();
8171 }
8172:
8173 (
8174 { before(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); }
8175 ruleExponentialOp
8176 { after(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); }
8177 )
8178;
8179finally {
8180 restoreStackSize(stackSize);
8181}
8182
8183rule__ExponentialExpression__RightAssignment_1_2
8184 @init {
8185 int stackSize = keepStackSize();
8186 }
8187:
8188 (
8189 { before(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); }
8190 ruleExponentialExpression
8191 { after(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); }
8192 )
8193;
8194finally {
8195 restoreStackSize(stackSize);
8196}
8197
8198rule__UnaryExpression__OpAssignment_1_1
8199 @init {
8200 int stackSize = keepStackSize();
8201 }
8202:
8203 (
8204 { before(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); }
8205 ruleUnaryOp
8206 { after(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); }
8207 )
8208;
8209finally {
8210 restoreStackSize(stackSize);
8211}
8212
8213rule__UnaryExpression__BodyAssignment_1_2
8214 @init {
8215 int stackSize = keepStackSize();
8216 }
8217:
8218 (
8219 { before(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); }
8220 ruleAggregationExpression
8221 { after(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); }
8222 )
8223;
8224finally {
8225 restoreStackSize(stackSize);
8226}
8227
8228rule__Count__BodyAssignment_2
8229 @init {
8230 int stackSize = keepStackSize();
8231 }
8232:
8233 (
8234 { before(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); }
8235 ruleExpression
8236 { after(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); }
8237 )
8238;
8239finally {
8240 restoreStackSize(stackSize);
8241}
8242
8243rule__Aggregation__OpAssignment_0
8244 @init {
8245 int stackSize = keepStackSize();
8246 }
8247:
8248 (
8249 { before(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); }
8250 ruleAggregationOp
8251 { after(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); }
8252 )
8253;
8254finally {
8255 restoreStackSize(stackSize);
8256}
8257
8258rule__Aggregation__BodyAssignment_2
8259 @init {
8260 int stackSize = keepStackSize();
8261 }
8262:
8263 (
8264 { before(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); }
8265 ruleExpression
8266 { after(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); }
8267 )
8268;
8269finally {
8270 restoreStackSize(stackSize);
8271}
8272
8273rule__Aggregation__ConditionAssignment_4
8274 @init {
8275 int stackSize = keepStackSize();
8276 }
8277:
8278 (
8279 { before(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); }
8280 ruleExpression
8281 { after(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); }
8282 )
8283;
8284finally {
8285 restoreStackSize(stackSize);
8286}
8287
8288rule__Call__FunctorAssignment_0
8289 @init {
8290 int stackSize = keepStackSize();
8291 }
8292:
8293 (
8294 { before(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); }
8295 ruleReference
8296 { after(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); }
8297 )
8298;
8299finally {
8300 restoreStackSize(stackSize);
8301}
8302
8303rule__Call__TransitiveClosureAssignment_1_0
8304 @init {
8305 int stackSize = keepStackSize();
8306 }
8307:
8308 (
8309 { before(grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); }
8310 RULE_TRANSITIVE_CLOSURE
8311 { after(grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); }
8312 )
8313;
8314finally {
8315 restoreStackSize(stackSize);
8316}
8317
8318rule__Call__ReflexiveTransitiveClosureAssignment_1_1
8319 @init {
8320 int stackSize = keepStackSize();
8321 }
8322:
8323 (
8324 { before(grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); }
8325 RULE_REFLEXIVE_TRANSITIVE_CLOSURE
8326 { after(grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); }
8327 )
8328;
8329finally {
8330 restoreStackSize(stackSize);
8331}
8332
8333rule__Call__ArgumentListAssignment_2
8334 @init {
8335 int stackSize = keepStackSize();
8336 }
8337:
8338 (
8339 { before(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); }
8340 ruleArgumentList
8341 { after(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); }
8342 )
8343;
8344finally {
8345 restoreStackSize(stackSize);
8346}
8347
8348rule__ArgumentList__ArgumentsAssignment_2_0
8349 @init {
8350 int stackSize = keepStackSize();
8351 }
8352:
8353 (
8354 { before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); }
8355 ruleArgument
8356 { after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); }
8357 )
8358;
8359finally {
8360 restoreStackSize(stackSize);
8361}
8362
8363rule__ArgumentList__ArgumentsAssignment_2_1_1
8364 @init {
8365 int stackSize = keepStackSize();
8366 }
8367:
8368 (
8369 { before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); }
8370 ruleArgument
8371 { after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); }
8372 )
8373;
8374finally {
8375 restoreStackSize(stackSize);
8376}
8377
8378rule__ExpressionArgument__BodyAssignment
8379 @init {
8380 int stackSize = keepStackSize();
8381 }
8382:
8383 (
8384 { before(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); }
8385 ruleComparisonExpression
8386 { after(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); }
8387 )
8388;
8389finally {
8390 restoreStackSize(stackSize);
8391}
8392
8393rule__TypedArgument__TypeAssignment_0
8394 @init {
8395 int stackSize = keepStackSize();
8396 }
8397:
8398 (
8399 { before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
8400 (
8401 { before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
8402 ruleQualifiedName
8403 { after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
8404 )
8405 { after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
8406 )
8407;
8408finally {
8409 restoreStackSize(stackSize);
8410}
8411
8412rule__TypedArgument__VariableAssignment_1
8413 @init {
8414 int stackSize = keepStackSize();
8415 }
8416:
8417 (
8418 { before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); }
8419 (
8420 { before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); }
8421 ruleQualifiedName
8422 { after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); }
8423 )
8424 { after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); }
8425 )
8426;
8427finally {
8428 restoreStackSize(stackSize);
8429}
8430
8431rule__TypedStarArgument__TypeAssignment_0
8432 @init {
8433 int stackSize = keepStackSize();
8434 }
8435:
8436 (
8437 { before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
8438 (
8439 { before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
8440 ruleQualifiedName
8441 { after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
8442 )
8443 { after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
8444 )
8445;
8446finally {
8447 restoreStackSize(stackSize);
8448}
8449
8450rule__Reference__ReferredAssignment
8451 @init {
8452 int stackSize = keepStackSize();
8453 }
8454:
8455 (
8456 { before(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); }
8457 (
8458 { before(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); }
8459 ruleQualifiedName
8460 { after(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); }
8461 )
8462 { after(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); }
8463 )
8464;
8465finally {
8466 restoreStackSize(stackSize);
8467}
8468
8469rule__Interval__LowerBoundAssignment_1
8470 @init {
8471 int stackSize = keepStackSize();
8472 }
8473:
8474 (
8475 { before(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); }
8476 ruleExpression
8477 { after(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); }
8478 )
8479;
8480finally {
8481 restoreStackSize(stackSize);
8482}
8483
8484rule__Interval__UpperBoundAssignment_3
8485 @init {
8486 int stackSize = keepStackSize();
8487 }
8488:
8489 (
8490 { before(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); }
8491 ruleExpression
8492 { after(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); }
8493 )
8494;
8495finally {
8496 restoreStackSize(stackSize);
8497}
8498
8499rule__LogicLiteral__ValueAssignment
8500 @init {
8501 int stackSize = keepStackSize();
8502 }
8503:
8504 (
8505 { before(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); }
8506 ruleLogicValue
8507 { after(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); }
8508 )
8509;
8510finally {
8511 restoreStackSize(stackSize);
8512}
8513
8514rule__NumericLiteral__ValueAssignment
8515 @init {
8516 int stackSize = keepStackSize();
8517 }
8518:
8519 (
8520 { before(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); }
8521 ruleReal
8522 { after(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); }
8523 )
8524;
8525finally {
8526 restoreStackSize(stackSize);
8527}
8528
8529rule__StringLiteral__ValueAssignment
8530 @init {
8531 int stackSize = keepStackSize();
8532 }
8533:
8534 (
8535 { before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); }
8536 RULE_STRING
8537 { after(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); }
8538 )
8539;
8540finally {
8541 restoreStackSize(stackSize);
8542}
8543
8544rule__ClassDefinition__AbstractAssignment_0
8545 @init {
8546 int stackSize = keepStackSize();
8547 }
8548:
8549 (
8550 { before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
8551 (
8552 { before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
8553 Abstract
8554 { after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
8555 )
8556 { after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
8557 )
8558;
8559finally {
8560 restoreStackSize(stackSize);
8561}
8562
8563rule__ClassDefinition__NameAssignment_2
8564 @init {
8565 int stackSize = keepStackSize();
8566 }
8567:
8568 (
8569 { before(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); }
8570 RULE_ID
8571 { after(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); }
8572 )
8573;
8574finally {
8575 restoreStackSize(stackSize);
8576}
8577
8578rule__ClassDefinition__SuperclassesAssignment_3_1
8579 @init {
8580 int stackSize = keepStackSize();
8581 }
8582:
8583 (
8584 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); }
8585 (
8586 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); }
8587 ruleQualifiedName
8588 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); }
8589 )
8590 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); }
8591 )
8592;
8593finally {
8594 restoreStackSize(stackSize);
8595}
8596
8597rule__ClassDefinition__SuperclassesAssignment_3_2_1
8598 @init {
8599 int stackSize = keepStackSize();
8600 }
8601:
8602 (
8603 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); }
8604 (
8605 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); }
8606 ruleQualifiedName
8607 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); }
8608 )
8609 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); }
8610 )
8611;
8612finally {
8613 restoreStackSize(stackSize);
8614}
8615
8616rule__ClassDefinition__MembersAssignment_5
8617 @init {
8618 int stackSize = keepStackSize();
8619 }
8620:
8621 (
8622 { before(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); }
8623 ruleMemberDefinition
8624 { after(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); }
8625 )
8626;
8627finally {
8628 restoreStackSize(stackSize);
8629}
8630
8631rule__MemberDefinition__ContainmentAssignment_0
8632 @init {
8633 int stackSize = keepStackSize();
8634 }
8635:
8636 (
8637 { before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
8638 (
8639 { before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
8640 Contains
8641 { after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
8642 )
8643 { after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
8644 )
8645;
8646finally {
8647 restoreStackSize(stackSize);
8648}
8649
8650rule__MemberDefinition__TypeAssignment_1
8651 @init {
8652 int stackSize = keepStackSize();
8653 }
8654:
8655 (
8656 { before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
8657 (
8658 { before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
8659 ruleQualifiedName
8660 { after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
8661 )
8662 { after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
8663 )
8664;
8665finally {
8666 restoreStackSize(stackSize);
8667}
8668
8669rule__MemberDefinition__MultiplicityAssignment_2
8670 @init {
8671 int stackSize = keepStackSize();
8672 }
8673:
8674 (
8675 { before(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); }
8676 ruleMultiplicity
8677 { after(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); }
8678 )
8679;
8680finally {
8681 restoreStackSize(stackSize);
8682}
8683
8684rule__MemberDefinition__NameAssignment_3
8685 @init {
8686 int stackSize = keepStackSize();
8687 }
8688:
8689 (
8690 { before(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); }
8691 RULE_ID
8692 { after(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); }
8693 )
8694;
8695finally {
8696 restoreStackSize(stackSize);
8697}
8698
8699rule__MemberDefinition__OppositeAssignment_4_1
8700 @init {
8701 int stackSize = keepStackSize();
8702 }
8703:
8704 (
8705 { before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); }
8706 (
8707 { before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); }
8708 ruleQualifiedName
8709 { after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); }
8710 )
8711 { after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); }
8712 )
8713;
8714finally {
8715 restoreStackSize(stackSize);
8716}
8717
8718rule__ExactMultiplicity__MultiplicityAssignment_1
8719 @init {
8720 int stackSize = keepStackSize();
8721 }
8722:
8723 (
8724 { before(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); }
8725 ruleUpperMultiplicty
8726 { after(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); }
8727 )
8728;
8729finally {
8730 restoreStackSize(stackSize);
8731}
8732
8733rule__BoundedMultiplicity__LowerBoundAssignment_1
8734 @init {
8735 int stackSize = keepStackSize();
8736 }
8737:
8738 (
8739 { before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); }
8740 RULE_INT
8741 { after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); }
8742 )
8743;
8744finally {
8745 restoreStackSize(stackSize);
8746}
8747
8748rule__BoundedMultiplicity__UpperBoundAssignment_3
8749 @init {
8750 int stackSize = keepStackSize();
8751 }
8752:
8753 (
8754 { before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); }
8755 ruleUpperMultiplicty
8756 { after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); }
8757 )
8758;
8759finally {
8760 restoreStackSize(stackSize);
8761}
8762
8763rule__ExactScopeDefinition__TypeAssignment_1
8764 @init {
8765 int stackSize = keepStackSize();
8766 }
8767:
8768 (
8769 { before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
8770 (
8771 { before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
8772 ruleQualifiedName
8773 { after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
8774 )
8775 { after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
8776 )
8777;
8778finally {
8779 restoreStackSize(stackSize);
8780}
8781
8782rule__ExactScopeDefinition__ExactScopeAssignment_3
8783 @init {
8784 int stackSize = keepStackSize();
8785 }
8786:
8787 (
8788 { before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); }
8789 RULE_INT
8790 { after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); }
8791 )
8792;
8793finally {
8794 restoreStackSize(stackSize);
8795}
8796
8797rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0
8798 @init {
8799 int stackSize = keepStackSize();
8800 }
8801:
8802 (
8803 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); }
8804 RULE_INT
8805 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); }
8806 )
8807;
8808finally {
8809 restoreStackSize(stackSize);
8810}
8811
8812rule__BoundedScopeDefinition__TypeAssignment_1_0_1
8813 @init {
8814 int stackSize = keepStackSize();
8815 }
8816:
8817 (
8818 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); }
8819 (
8820 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); }
8821 ruleQualifiedName
8822 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); }
8823 )
8824 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); }
8825 )
8826;
8827finally {
8828 restoreStackSize(stackSize);
8829}
8830
8831rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3
8832 @init {
8833 int stackSize = keepStackSize();
8834 }
8835:
8836 (
8837 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); }
8838 RULE_INT
8839 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); }
8840 )
8841;
8842finally {
8843 restoreStackSize(stackSize);
8844}
8845
8846rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0
8847 @init {
8848 int stackSize = keepStackSize();
8849 }
8850:
8851 (
8852 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); }
8853 RULE_INT
8854 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); }
8855 )
8856;
8857finally {
8858 restoreStackSize(stackSize);
8859}
8860
8861rule__BoundedScopeDefinition__TypeAssignment_1_1_2
8862 @init {
8863 int stackSize = keepStackSize();
8864 }
8865:
8866 (
8867 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); }
8868 (
8869 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); }
8870 ruleQualifiedName
8871 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); }
8872 )
8873 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); }
8874 )
8875;
8876finally {
8877 restoreStackSize(stackSize);
8878}
8879
8880rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1
8881 @init {
8882 int stackSize = keepStackSize();
8883 }
8884:
8885 (
8886 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); }
8887 RULE_INT
8888 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); }
8889 )
8890;
8891finally {
8892 restoreStackSize(stackSize);
8893}
8894
8895rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0
8896 @init {
8897 int stackSize = keepStackSize();
8898 }
8899:
8900 (
8901 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); }
8902 RULE_INT
8903 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); }
8904 )
8905;
8906finally {
8907 restoreStackSize(stackSize);
8908}
8909
8910rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2
8911 @init {
8912 int stackSize = keepStackSize();
8913 }
8914:
8915 (
8916 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); }
8917 (
8918 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); }
8919 ruleQualifiedName
8920 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); }
8921 )
8922 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); }
8923 )
8924;
8925finally {
8926 restoreStackSize(stackSize);
8927}
8928
8929rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0
8930 @init {
8931 int stackSize = keepStackSize();
8932 }
8933:
8934 (
8935 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); }
8936 (
8937 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); }
8938 ruleQualifiedName
8939 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); }
8940 )
8941 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); }
8942 )
8943;
8944finally {
8945 restoreStackSize(stackSize);
8946}
8947
8948rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2
8949 @init {
8950 int stackSize = keepStackSize();
8951 }
8952:
8953 (
8954 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); }
8955 RULE_INT
8956 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); }
8957 )
8958;
8959finally {
8960 restoreStackSize(stackSize);
8961}
8962
8963rule__ObjectiveDefinition__KindAssignment_0
8964 @init {
8965 int stackSize = keepStackSize();
8966 }
8967:
8968 (
8969 { before(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); }
8970 ruleObjectiveKind
8971 { after(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); }
8972 )
8973;
8974finally {
8975 restoreStackSize(stackSize);
8976}
8977
8978rule__ObjectiveDefinition__ObjectiveAssignment_1
8979 @init {
8980 int stackSize = keepStackSize();
8981 }
8982:
8983 (
8984 { before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); }
8985 ruleExpression
8986 { after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); }
8987 )
8988;
8989finally {
8990 restoreStackSize(stackSize);
8991}
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-23 05:33:30 +0000