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