aboutsummaryrefslogtreecommitdiffstats
path: root/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g
diff options
context:
space:
mode:
authorLibravatar Kristóf Marussy <marussy@mit.bme.hu>2021-06-29 14:06:14 +0200
committerLibravatar Kristóf Marussy <marussy@mit.bme.hu>2021-06-29 14:06:14 +0200
commit6636b18597946aa71f774f02809c1dda3c902cbc (patch)
tree9fb0bef89bce19a880fca2d1269c04838a2e1286 /language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g
parentWebpack build for frontend (diff)
downloadrefinery-6636b18597946aa71f774f02809c1dda3c902cbc.tar.gz
refinery-6636b18597946aa71f774f02809c1dda3c902cbc.tar.zst
refinery-6636b18597946aa71f774f02809c1dda3c902cbc.zip
Remove xtext-gen generated files
They are regenerated on each build
Diffstat (limited to 'language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g')
-rw-r--r--language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g5755
1 files changed, 0 insertions, 5755 deletions
diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g
deleted file mode 100644
index 1fc6285d..00000000
--- a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g
+++ /dev/null
@@ -1,5755 +0,0 @@
1/*
2 * generated by Xtext 2.26.0.M1
3 */
4grammar InternalProblem;
5
6options {
7 superClass=AbstractInternalContentAssistParser;
8}
9
10@lexer::header {
11package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal;
12
13// Hack: Use our own Lexer superclass by means of import.
14// Currently there is no other way to specify the superclass for the lexer.
15import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
16}
17
18@parser::header {
19package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal;
20
21import java.io.InputStream;
22import org.eclipse.xtext.*;
23import org.eclipse.xtext.parser.*;
24import org.eclipse.xtext.parser.impl.*;
25import org.eclipse.emf.ecore.util.EcoreUtil;
26import org.eclipse.emf.ecore.EObject;
27import org.eclipse.xtext.parser.antlr.XtextTokenStream;
28import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
29import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
30import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
31import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess;
32
33}
34@parser::members {
35 private ProblemGrammarAccess grammarAccess;
36
37 public void setGrammarAccess(ProblemGrammarAccess grammarAccess) {
38 this.grammarAccess = grammarAccess;
39 }
40
41 @Override
42 protected Grammar getGrammar() {
43 return grammarAccess.getGrammar();
44 }
45
46 @Override
47 protected String getValueForTokenName(String tokenName) {
48 return tokenName;
49 }
50}
51
52// Entry rule entryRuleProblem
53entryRuleProblem
54:
55{ before(grammarAccess.getProblemRule()); }
56 ruleProblem
57{ after(grammarAccess.getProblemRule()); }
58 EOF
59;
60
61// Rule Problem
62ruleProblem
63 @init {
64 int stackSize = keepStackSize();
65 }
66 :
67 (
68 { before(grammarAccess.getProblemAccess().getGroup()); }
69 (rule__Problem__Group__0)
70 { after(grammarAccess.getProblemAccess().getGroup()); }
71 )
72;
73finally {
74 restoreStackSize(stackSize);
75}
76
77// Entry rule entryRuleStatement
78entryRuleStatement
79:
80{ before(grammarAccess.getStatementRule()); }
81 ruleStatement
82{ after(grammarAccess.getStatementRule()); }
83 EOF
84;
85
86// Rule Statement
87ruleStatement
88 @init {
89 int stackSize = keepStackSize();
90 }
91 :
92 (
93 { before(grammarAccess.getStatementAccess().getAlternatives()); }
94 (rule__Statement__Alternatives)
95 { after(grammarAccess.getStatementAccess().getAlternatives()); }
96 )
97;
98finally {
99 restoreStackSize(stackSize);
100}
101
102// Entry rule entryRuleClassDeclaration
103entryRuleClassDeclaration
104:
105{ before(grammarAccess.getClassDeclarationRule()); }
106 ruleClassDeclaration
107{ after(grammarAccess.getClassDeclarationRule()); }
108 EOF
109;
110
111// Rule ClassDeclaration
112ruleClassDeclaration
113 @init {
114 int stackSize = keepStackSize();
115 }
116 :
117 (
118 { before(grammarAccess.getClassDeclarationAccess().getGroup()); }
119 (rule__ClassDeclaration__Group__0)
120 { after(grammarAccess.getClassDeclarationAccess().getGroup()); }
121 )
122;
123finally {
124 restoreStackSize(stackSize);
125}
126
127// Entry rule entryRuleEnumDeclaration
128entryRuleEnumDeclaration
129:
130{ before(grammarAccess.getEnumDeclarationRule()); }
131 ruleEnumDeclaration
132{ after(grammarAccess.getEnumDeclarationRule()); }
133 EOF
134;
135
136// Rule EnumDeclaration
137ruleEnumDeclaration
138 @init {
139 int stackSize = keepStackSize();
140 }
141 :
142 (
143 { before(grammarAccess.getEnumDeclarationAccess().getGroup()); }
144 (rule__EnumDeclaration__Group__0)
145 { after(grammarAccess.getEnumDeclarationAccess().getGroup()); }
146 )
147;
148finally {
149 restoreStackSize(stackSize);
150}
151
152// Entry rule entryRuleEnumLiteral
153entryRuleEnumLiteral
154:
155{ before(grammarAccess.getEnumLiteralRule()); }
156 ruleEnumLiteral
157{ after(grammarAccess.getEnumLiteralRule()); }
158 EOF
159;
160
161// Rule EnumLiteral
162ruleEnumLiteral
163 @init {
164 int stackSize = keepStackSize();
165 }
166 :
167 (
168 { before(grammarAccess.getEnumLiteralAccess().getNameAssignment()); }
169 (rule__EnumLiteral__NameAssignment)
170 { after(grammarAccess.getEnumLiteralAccess().getNameAssignment()); }
171 )
172;
173finally {
174 restoreStackSize(stackSize);
175}
176
177// Entry rule entryRuleReferenceDeclaration
178entryRuleReferenceDeclaration
179:
180{ before(grammarAccess.getReferenceDeclarationRule()); }
181 ruleReferenceDeclaration
182{ after(grammarAccess.getReferenceDeclarationRule()); }
183 EOF
184;
185
186// Rule ReferenceDeclaration
187ruleReferenceDeclaration
188 @init {
189 int stackSize = keepStackSize();
190 }
191 :
192 (
193 { before(grammarAccess.getReferenceDeclarationAccess().getGroup()); }
194 (rule__ReferenceDeclaration__Group__0)
195 { after(grammarAccess.getReferenceDeclarationAccess().getGroup()); }
196 )
197;
198finally {
199 restoreStackSize(stackSize);
200}
201
202// Entry rule entryRulePredicateDefinition
203entryRulePredicateDefinition
204:
205{ before(grammarAccess.getPredicateDefinitionRule()); }
206 rulePredicateDefinition
207{ after(grammarAccess.getPredicateDefinitionRule()); }
208 EOF
209;
210
211// Rule PredicateDefinition
212rulePredicateDefinition
213 @init {
214 int stackSize = keepStackSize();
215 }
216 :
217 (
218 { before(grammarAccess.getPredicateDefinitionAccess().getGroup()); }
219 (rule__PredicateDefinition__Group__0)
220 { after(grammarAccess.getPredicateDefinitionAccess().getGroup()); }
221 )
222;
223finally {
224 restoreStackSize(stackSize);
225}
226
227// Entry rule entryRuleParameter
228entryRuleParameter
229:
230{ before(grammarAccess.getParameterRule()); }
231 ruleParameter
232{ after(grammarAccess.getParameterRule()); }
233 EOF
234;
235
236// Rule Parameter
237ruleParameter
238 @init {
239 int stackSize = keepStackSize();
240 }
241 :
242 (
243 { before(grammarAccess.getParameterAccess().getGroup()); }
244 (rule__Parameter__Group__0)
245 { after(grammarAccess.getParameterAccess().getGroup()); }
246 )
247;
248finally {
249 restoreStackSize(stackSize);
250}
251
252// Entry rule entryRuleConjunction
253entryRuleConjunction
254:
255{ before(grammarAccess.getConjunctionRule()); }
256 ruleConjunction
257{ after(grammarAccess.getConjunctionRule()); }
258 EOF
259;
260
261// Rule Conjunction
262ruleConjunction
263 @init {
264 int stackSize = keepStackSize();
265 }
266 :
267 (
268 { before(grammarAccess.getConjunctionAccess().getGroup()); }
269 (rule__Conjunction__Group__0)
270 { after(grammarAccess.getConjunctionAccess().getGroup()); }
271 )
272;
273finally {
274 restoreStackSize(stackSize);
275}
276
277// Entry rule entryRuleLiteral
278entryRuleLiteral
279:
280{ before(grammarAccess.getLiteralRule()); }
281 ruleLiteral
282{ after(grammarAccess.getLiteralRule()); }
283 EOF
284;
285
286// Rule Literal
287ruleLiteral
288 @init {
289 int stackSize = keepStackSize();
290 }
291 :
292 (
293 { before(grammarAccess.getLiteralAccess().getAlternatives()); }
294 (rule__Literal__Alternatives)
295 { after(grammarAccess.getLiteralAccess().getAlternatives()); }
296 )
297;
298finally {
299 restoreStackSize(stackSize);
300}
301
302// Entry rule entryRuleNegativeLiteral
303entryRuleNegativeLiteral
304:
305{ before(grammarAccess.getNegativeLiteralRule()); }
306 ruleNegativeLiteral
307{ after(grammarAccess.getNegativeLiteralRule()); }
308 EOF
309;
310
311// Rule NegativeLiteral
312ruleNegativeLiteral
313 @init {
314 int stackSize = keepStackSize();
315 }
316 :
317 (
318 { before(grammarAccess.getNegativeLiteralAccess().getGroup()); }
319 (rule__NegativeLiteral__Group__0)
320 { after(grammarAccess.getNegativeLiteralAccess().getGroup()); }
321 )
322;
323finally {
324 restoreStackSize(stackSize);
325}
326
327// Entry rule entryRuleAtom
328entryRuleAtom
329:
330{ before(grammarAccess.getAtomRule()); }
331 ruleAtom
332{ after(grammarAccess.getAtomRule()); }
333 EOF
334;
335
336// Rule Atom
337ruleAtom
338 @init {
339 int stackSize = keepStackSize();
340 }
341 :
342 (
343 { before(grammarAccess.getAtomAccess().getGroup()); }
344 (rule__Atom__Group__0)
345 { after(grammarAccess.getAtomAccess().getGroup()); }
346 )
347;
348finally {
349 restoreStackSize(stackSize);
350}
351
352// Entry rule entryRuleArgument
353entryRuleArgument
354:
355{ before(grammarAccess.getArgumentRule()); }
356 ruleArgument
357{ after(grammarAccess.getArgumentRule()); }
358 EOF
359;
360
361// Rule Argument
362ruleArgument
363 @init {
364 int stackSize = keepStackSize();
365 }
366 :
367 (
368 { before(grammarAccess.getArgumentAccess().getAlternatives()); }
369 (rule__Argument__Alternatives)
370 { after(grammarAccess.getArgumentAccess().getAlternatives()); }
371 )
372;
373finally {
374 restoreStackSize(stackSize);
375}
376
377// Entry rule entryRuleVariableOrNodeArgument
378entryRuleVariableOrNodeArgument
379:
380{ before(grammarAccess.getVariableOrNodeArgumentRule()); }
381 ruleVariableOrNodeArgument
382{ after(grammarAccess.getVariableOrNodeArgumentRule()); }
383 EOF
384;
385
386// Rule VariableOrNodeArgument
387ruleVariableOrNodeArgument
388 @init {
389 int stackSize = keepStackSize();
390 }
391 :
392 (
393 { before(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeAssignment()); }
394 (rule__VariableOrNodeArgument__VariableOrNodeAssignment)
395 { after(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeAssignment()); }
396 )
397;
398finally {
399 restoreStackSize(stackSize);
400}
401
402// Entry rule entryRuleConstantArgument
403entryRuleConstantArgument
404:
405{ before(grammarAccess.getConstantArgumentRule()); }
406 ruleConstantArgument
407{ after(grammarAccess.getConstantArgumentRule()); }
408 EOF
409;
410
411// Rule ConstantArgument
412ruleConstantArgument
413 @init {
414 int stackSize = keepStackSize();
415 }
416 :
417 (
418 { before(grammarAccess.getConstantArgumentAccess().getConstantAssignment()); }
419 (rule__ConstantArgument__ConstantAssignment)
420 { after(grammarAccess.getConstantArgumentAccess().getConstantAssignment()); }
421 )
422;
423finally {
424 restoreStackSize(stackSize);
425}
426
427// Entry rule entryRuleAssertion
428entryRuleAssertion
429:
430{ before(grammarAccess.getAssertionRule()); }
431 ruleAssertion
432{ after(grammarAccess.getAssertionRule()); }
433 EOF
434;
435
436// Rule Assertion
437ruleAssertion
438 @init {
439 int stackSize = keepStackSize();
440 }
441 :
442 (
443 { before(grammarAccess.getAssertionAccess().getGroup()); }
444 (rule__Assertion__Group__0)
445 { after(grammarAccess.getAssertionAccess().getGroup()); }
446 )
447;
448finally {
449 restoreStackSize(stackSize);
450}
451
452// Entry rule entryRuleAssertionArgument
453entryRuleAssertionArgument
454:
455{ before(grammarAccess.getAssertionArgumentRule()); }
456 ruleAssertionArgument
457{ after(grammarAccess.getAssertionArgumentRule()); }
458 EOF
459;
460
461// Rule AssertionArgument
462ruleAssertionArgument
463 @init {
464 int stackSize = keepStackSize();
465 }
466 :
467 (
468 { before(grammarAccess.getAssertionArgumentAccess().getAlternatives()); }
469 (rule__AssertionArgument__Alternatives)
470 { after(grammarAccess.getAssertionArgumentAccess().getAlternatives()); }
471 )
472;
473finally {
474 restoreStackSize(stackSize);
475}
476
477// Entry rule entryRuleNodeAssertionArgument
478entryRuleNodeAssertionArgument
479:
480{ before(grammarAccess.getNodeAssertionArgumentRule()); }
481 ruleNodeAssertionArgument
482{ after(grammarAccess.getNodeAssertionArgumentRule()); }
483 EOF
484;
485
486// Rule NodeAssertionArgument
487ruleNodeAssertionArgument
488 @init {
489 int stackSize = keepStackSize();
490 }
491 :
492 (
493 { before(grammarAccess.getNodeAssertionArgumentAccess().getNodeAssignment()); }
494 (rule__NodeAssertionArgument__NodeAssignment)
495 { after(grammarAccess.getNodeAssertionArgumentAccess().getNodeAssignment()); }
496 )
497;
498finally {
499 restoreStackSize(stackSize);
500}
501
502// Entry rule entryRuleConstantAssertionArgument
503entryRuleConstantAssertionArgument
504:
505{ before(grammarAccess.getConstantAssertionArgumentRule()); }
506 ruleConstantAssertionArgument
507{ after(grammarAccess.getConstantAssertionArgumentRule()); }
508 EOF
509;
510
511// Rule ConstantAssertionArgument
512ruleConstantAssertionArgument
513 @init {
514 int stackSize = keepStackSize();
515 }
516 :
517 (
518 { before(grammarAccess.getConstantAssertionArgumentAccess().getConstantAssignment()); }
519 (rule__ConstantAssertionArgument__ConstantAssignment)
520 { after(grammarAccess.getConstantAssertionArgumentAccess().getConstantAssignment()); }
521 )
522;
523finally {
524 restoreStackSize(stackSize);
525}
526
527// Entry rule entryRuleNodeValueAssertion
528entryRuleNodeValueAssertion
529:
530{ before(grammarAccess.getNodeValueAssertionRule()); }
531 ruleNodeValueAssertion
532{ after(grammarAccess.getNodeValueAssertionRule()); }
533 EOF
534;
535
536// Rule NodeValueAssertion
537ruleNodeValueAssertion
538 @init {
539 int stackSize = keepStackSize();
540 }
541 :
542 (
543 { before(grammarAccess.getNodeValueAssertionAccess().getGroup()); }
544 (rule__NodeValueAssertion__Group__0)
545 { after(grammarAccess.getNodeValueAssertionAccess().getGroup()); }
546 )
547;
548finally {
549 restoreStackSize(stackSize);
550}
551
552// Entry rule entryRuleConstant
553entryRuleConstant
554:
555{ before(grammarAccess.getConstantRule()); }
556 ruleConstant
557{ after(grammarAccess.getConstantRule()); }
558 EOF
559;
560
561// Rule Constant
562ruleConstant
563 @init {
564 int stackSize = keepStackSize();
565 }
566 :
567 (
568 { before(grammarAccess.getConstantAccess().getAlternatives()); }
569 (rule__Constant__Alternatives)
570 { after(grammarAccess.getConstantAccess().getAlternatives()); }
571 )
572;
573finally {
574 restoreStackSize(stackSize);
575}
576
577// Entry rule entryRuleIntConstant
578entryRuleIntConstant
579:
580{ before(grammarAccess.getIntConstantRule()); }
581 ruleIntConstant
582{ after(grammarAccess.getIntConstantRule()); }
583 EOF
584;
585
586// Rule IntConstant
587ruleIntConstant
588 @init {
589 int stackSize = keepStackSize();
590 }
591 :
592 (
593 { before(grammarAccess.getIntConstantAccess().getIntValueAssignment()); }
594 (rule__IntConstant__IntValueAssignment)
595 { after(grammarAccess.getIntConstantAccess().getIntValueAssignment()); }
596 )
597;
598finally {
599 restoreStackSize(stackSize);
600}
601
602// Entry rule entryRuleRealConstant
603entryRuleRealConstant
604:
605{ before(grammarAccess.getRealConstantRule()); }
606 ruleRealConstant
607{ after(grammarAccess.getRealConstantRule()); }
608 EOF
609;
610
611// Rule RealConstant
612ruleRealConstant
613 @init {
614 int stackSize = keepStackSize();
615 }
616 :
617 (
618 { before(grammarAccess.getRealConstantAccess().getRealValueAssignment()); }
619 (rule__RealConstant__RealValueAssignment)
620 { after(grammarAccess.getRealConstantAccess().getRealValueAssignment()); }
621 )
622;
623finally {
624 restoreStackSize(stackSize);
625}
626
627// Entry rule entryRuleStringConstant
628entryRuleStringConstant
629:
630{ before(grammarAccess.getStringConstantRule()); }
631 ruleStringConstant
632{ after(grammarAccess.getStringConstantRule()); }
633 EOF
634;
635
636// Rule StringConstant
637ruleStringConstant
638 @init {
639 int stackSize = keepStackSize();
640 }
641 :
642 (
643 { before(grammarAccess.getStringConstantAccess().getStringValueAssignment()); }
644 (rule__StringConstant__StringValueAssignment)
645 { after(grammarAccess.getStringConstantAccess().getStringValueAssignment()); }
646 )
647;
648finally {
649 restoreStackSize(stackSize);
650}
651
652// Entry rule entryRuleScopeDeclaration
653entryRuleScopeDeclaration
654:
655{ before(grammarAccess.getScopeDeclarationRule()); }
656 ruleScopeDeclaration
657{ after(grammarAccess.getScopeDeclarationRule()); }
658 EOF
659;
660
661// Rule ScopeDeclaration
662ruleScopeDeclaration
663 @init {
664 int stackSize = keepStackSize();
665 }
666 :
667 (
668 { before(grammarAccess.getScopeDeclarationAccess().getGroup()); }
669 (rule__ScopeDeclaration__Group__0)
670 { after(grammarAccess.getScopeDeclarationAccess().getGroup()); }
671 )
672;
673finally {
674 restoreStackSize(stackSize);
675}
676
677// Entry rule entryRuleTypeScope
678entryRuleTypeScope
679:
680{ before(grammarAccess.getTypeScopeRule()); }
681 ruleTypeScope
682{ after(grammarAccess.getTypeScopeRule()); }
683 EOF
684;
685
686// Rule TypeScope
687ruleTypeScope
688 @init {
689 int stackSize = keepStackSize();
690 }
691 :
692 (
693 { before(grammarAccess.getTypeScopeAccess().getGroup()); }
694 (rule__TypeScope__Group__0)
695 { after(grammarAccess.getTypeScopeAccess().getGroup()); }
696 )
697;
698finally {
699 restoreStackSize(stackSize);
700}
701
702// Entry rule entryRuleMultiplicity
703entryRuleMultiplicity
704:
705{ before(grammarAccess.getMultiplicityRule()); }
706 ruleMultiplicity
707{ after(grammarAccess.getMultiplicityRule()); }
708 EOF
709;
710
711// Rule Multiplicity
712ruleMultiplicity
713 @init {
714 int stackSize = keepStackSize();
715 }
716 :
717 (
718 { before(grammarAccess.getMultiplicityAccess().getAlternatives()); }
719 (rule__Multiplicity__Alternatives)
720 { after(grammarAccess.getMultiplicityAccess().getAlternatives()); }
721 )
722;
723finally {
724 restoreStackSize(stackSize);
725}
726
727// Entry rule entryRuleDefiniteMultiplicity
728entryRuleDefiniteMultiplicity
729:
730{ before(grammarAccess.getDefiniteMultiplicityRule()); }
731 ruleDefiniteMultiplicity
732{ after(grammarAccess.getDefiniteMultiplicityRule()); }
733 EOF
734;
735
736// Rule DefiniteMultiplicity
737ruleDefiniteMultiplicity
738 @init {
739 int stackSize = keepStackSize();
740 }
741 :
742 (
743 { before(grammarAccess.getDefiniteMultiplicityAccess().getAlternatives()); }
744 (rule__DefiniteMultiplicity__Alternatives)
745 { after(grammarAccess.getDefiniteMultiplicityAccess().getAlternatives()); }
746 )
747;
748finally {
749 restoreStackSize(stackSize);
750}
751
752// Entry rule entryRuleUnboundedMultiplicity
753entryRuleUnboundedMultiplicity
754:
755{ before(grammarAccess.getUnboundedMultiplicityRule()); }
756 ruleUnboundedMultiplicity
757{ after(grammarAccess.getUnboundedMultiplicityRule()); }
758 EOF
759;
760
761// Rule UnboundedMultiplicity
762ruleUnboundedMultiplicity
763 @init {
764 int stackSize = keepStackSize();
765 }
766 :
767 (
768 { before(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction()); }
769 ()
770 { after(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction()); }
771 )
772;
773finally {
774 restoreStackSize(stackSize);
775}
776
777// Entry rule entryRuleRangeMultiplicity
778entryRuleRangeMultiplicity
779:
780{ before(grammarAccess.getRangeMultiplicityRule()); }
781 ruleRangeMultiplicity
782{ after(grammarAccess.getRangeMultiplicityRule()); }
783 EOF
784;
785
786// Rule RangeMultiplicity
787ruleRangeMultiplicity
788 @init {
789 int stackSize = keepStackSize();
790 }
791 :
792 (
793 { before(grammarAccess.getRangeMultiplicityAccess().getGroup()); }
794 (rule__RangeMultiplicity__Group__0)
795 { after(grammarAccess.getRangeMultiplicityAccess().getGroup()); }
796 )
797;
798finally {
799 restoreStackSize(stackSize);
800}
801
802// Entry rule entryRuleExactMultiplicity
803entryRuleExactMultiplicity
804:
805{ before(grammarAccess.getExactMultiplicityRule()); }
806 ruleExactMultiplicity
807{ after(grammarAccess.getExactMultiplicityRule()); }
808 EOF
809;
810
811// Rule ExactMultiplicity
812ruleExactMultiplicity
813 @init {
814 int stackSize = keepStackSize();
815 }
816 :
817 (
818 { before(grammarAccess.getExactMultiplicityAccess().getExactValueAssignment()); }
819 (rule__ExactMultiplicity__ExactValueAssignment)
820 { after(grammarAccess.getExactMultiplicityAccess().getExactValueAssignment()); }
821 )
822;
823finally {
824 restoreStackSize(stackSize);
825}
826
827// Entry rule entryRuleUpperBound
828entryRuleUpperBound
829:
830{ before(grammarAccess.getUpperBoundRule()); }
831 ruleUpperBound
832{ after(grammarAccess.getUpperBoundRule()); }
833 EOF
834;
835
836// Rule UpperBound
837ruleUpperBound
838 @init {
839 int stackSize = keepStackSize();
840 }
841 :
842 (
843 { before(grammarAccess.getUpperBoundAccess().getAlternatives()); }
844 (rule__UpperBound__Alternatives)
845 { after(grammarAccess.getUpperBoundAccess().getAlternatives()); }
846 )
847;
848finally {
849 restoreStackSize(stackSize);
850}
851
852// Entry rule entryRuleQualifiedName
853entryRuleQualifiedName
854@init {
855 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
856}
857:
858{ before(grammarAccess.getQualifiedNameRule()); }
859 ruleQualifiedName
860{ after(grammarAccess.getQualifiedNameRule()); }
861 EOF
862;
863finally {
864 myHiddenTokenState.restore();
865}
866
867// Rule QualifiedName
868ruleQualifiedName
869 @init {
870 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
871 int stackSize = keepStackSize();
872 }
873 :
874 (
875 { before(grammarAccess.getQualifiedNameAccess().getAlternatives()); }
876 (rule__QualifiedName__Alternatives)
877 { after(grammarAccess.getQualifiedNameAccess().getAlternatives()); }
878 )
879;
880finally {
881 restoreStackSize(stackSize);
882 myHiddenTokenState.restore();
883}
884
885// Entry rule entryRuleIdentifier
886entryRuleIdentifier
887:
888{ before(grammarAccess.getIdentifierRule()); }
889 ruleIdentifier
890{ after(grammarAccess.getIdentifierRule()); }
891 EOF
892;
893
894// Rule Identifier
895ruleIdentifier
896 @init {
897 int stackSize = keepStackSize();
898 }
899 :
900 (
901 { before(grammarAccess.getIdentifierAccess().getAlternatives()); }
902 (rule__Identifier__Alternatives)
903 { after(grammarAccess.getIdentifierAccess().getAlternatives()); }
904 )
905;
906finally {
907 restoreStackSize(stackSize);
908}
909
910// Entry rule entryRuleInteger
911entryRuleInteger
912@init {
913 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
914}
915:
916{ before(grammarAccess.getIntegerRule()); }
917 ruleInteger
918{ after(grammarAccess.getIntegerRule()); }
919 EOF
920;
921finally {
922 myHiddenTokenState.restore();
923}
924
925// Rule Integer
926ruleInteger
927 @init {
928 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
929 int stackSize = keepStackSize();
930 }
931 :
932 (
933 { before(grammarAccess.getIntegerAccess().getGroup()); }
934 (rule__Integer__Group__0)
935 { after(grammarAccess.getIntegerAccess().getGroup()); }
936 )
937;
938finally {
939 restoreStackSize(stackSize);
940 myHiddenTokenState.restore();
941}
942
943// Entry rule entryRuleReal
944entryRuleReal
945:
946{ before(grammarAccess.getRealRule()); }
947 ruleReal
948{ after(grammarAccess.getRealRule()); }
949 EOF
950;
951
952// Rule Real
953ruleReal
954 @init {
955 int stackSize = keepStackSize();
956 }
957 :
958 (
959 { before(grammarAccess.getRealAccess().getGroup()); }
960 (rule__Real__Group__0)
961 { after(grammarAccess.getRealAccess().getGroup()); }
962 )
963;
964finally {
965 restoreStackSize(stackSize);
966}
967
968// Rule LogicValue
969ruleLogicValue
970 @init {
971 int stackSize = keepStackSize();
972 }
973:
974 (
975 { before(grammarAccess.getLogicValueAccess().getAlternatives()); }
976 (rule__LogicValue__Alternatives)
977 { after(grammarAccess.getLogicValueAccess().getAlternatives()); }
978 )
979;
980finally {
981 restoreStackSize(stackSize);
982}
983
984// Rule ShortLogicValue
985ruleShortLogicValue
986 @init {
987 int stackSize = keepStackSize();
988 }
989:
990 (
991 { before(grammarAccess.getShortLogicValueAccess().getAlternatives()); }
992 (rule__ShortLogicValue__Alternatives)
993 { after(grammarAccess.getShortLogicValueAccess().getAlternatives()); }
994 )
995;
996finally {
997 restoreStackSize(stackSize);
998}
999
1000rule__Statement__Alternatives
1001 @init {
1002 int stackSize = keepStackSize();
1003 }
1004:
1005 (
1006 { before(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_0()); }
1007 ruleClassDeclaration
1008 { after(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_0()); }
1009 )
1010 |
1011 (
1012 { before(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_1()); }
1013 ruleEnumDeclaration
1014 { after(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_1()); }
1015 )
1016 |
1017 (
1018 { before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_2()); }
1019 rulePredicateDefinition
1020 { after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_2()); }
1021 )
1022 |
1023 (
1024 { before(grammarAccess.getStatementAccess().getAssertionParserRuleCall_3()); }
1025 ruleAssertion
1026 { after(grammarAccess.getStatementAccess().getAssertionParserRuleCall_3()); }
1027 )
1028 |
1029 (
1030 { before(grammarAccess.getStatementAccess().getNodeValueAssertionParserRuleCall_4()); }
1031 ruleNodeValueAssertion
1032 { after(grammarAccess.getStatementAccess().getNodeValueAssertionParserRuleCall_4()); }
1033 )
1034 |
1035 (
1036 { before(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_5()); }
1037 ruleScopeDeclaration
1038 { after(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_5()); }
1039 )
1040;
1041finally {
1042 restoreStackSize(stackSize);
1043}
1044
1045rule__ClassDeclaration__Alternatives_4
1046 @init {
1047 int stackSize = keepStackSize();
1048 }
1049:
1050 (
1051 { before(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); }
1052 (rule__ClassDeclaration__Group_4_0__0)
1053 { after(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); }
1054 )
1055 |
1056 (
1057 { before(grammarAccess.getClassDeclarationAccess().getFullStopKeyword_4_1()); }
1058 '.'
1059 { after(grammarAccess.getClassDeclarationAccess().getFullStopKeyword_4_1()); }
1060 )
1061;
1062finally {
1063 restoreStackSize(stackSize);
1064}
1065
1066rule__EnumDeclaration__Alternatives_2
1067 @init {
1068 int stackSize = keepStackSize();
1069 }
1070:
1071 (
1072 { before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); }
1073 (rule__EnumDeclaration__Group_2_0__0)
1074 { after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); }
1075 )
1076 |
1077 (
1078 { before(grammarAccess.getEnumDeclarationAccess().getFullStopKeyword_2_1()); }
1079 '.'
1080 { after(grammarAccess.getEnumDeclarationAccess().getFullStopKeyword_2_1()); }
1081 )
1082;
1083finally {
1084 restoreStackSize(stackSize);
1085}
1086
1087rule__EnumDeclaration__Alternatives_2_0_1_2
1088 @init {
1089 int stackSize = keepStackSize();
1090 }
1091:
1092 (
1093 { before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_2_0()); }
1094 ','
1095 { after(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_2_0()); }
1096 )
1097 |
1098 (
1099 { before(grammarAccess.getEnumDeclarationAccess().getSemicolonKeyword_2_0_1_2_1()); }
1100 ';'
1101 { after(grammarAccess.getEnumDeclarationAccess().getSemicolonKeyword_2_0_1_2_1()); }
1102 )
1103;
1104finally {
1105 restoreStackSize(stackSize);
1106}
1107
1108rule__ReferenceDeclaration__Alternatives_0
1109 @init {
1110 int stackSize = keepStackSize();
1111 }
1112:
1113 (
1114 { before(grammarAccess.getReferenceDeclarationAccess().getContainmentAssignment_0_0()); }
1115 (rule__ReferenceDeclaration__ContainmentAssignment_0_0)
1116 { after(grammarAccess.getReferenceDeclarationAccess().getContainmentAssignment_0_0()); }
1117 )
1118 |
1119 (
1120 { before(grammarAccess.getReferenceDeclarationAccess().getRefersKeyword_0_1()); }
1121 'refers'
1122 { after(grammarAccess.getReferenceDeclarationAccess().getRefersKeyword_0_1()); }
1123 )
1124;
1125finally {
1126 restoreStackSize(stackSize);
1127}
1128
1129rule__PredicateDefinition__Alternatives_0
1130 @init {
1131 int stackSize = keepStackSize();
1132 }
1133:
1134 (
1135 { before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); }
1136 (rule__PredicateDefinition__Group_0_0__0)
1137 { after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); }
1138 )
1139 |
1140 (
1141 { before(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_1()); }
1142 'pred'
1143 { after(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_1()); }
1144 )
1145;
1146finally {
1147 restoreStackSize(stackSize);
1148}
1149
1150rule__Literal__Alternatives
1151 @init {
1152 int stackSize = keepStackSize();
1153 }
1154:
1155 (
1156 { before(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); }
1157 ruleAtom
1158 { after(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); }
1159 )
1160 |
1161 (
1162 { before(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); }
1163 ruleNegativeLiteral
1164 { after(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); }
1165 )
1166;
1167finally {
1168 restoreStackSize(stackSize);
1169}
1170
1171rule__Argument__Alternatives
1172 @init {
1173 int stackSize = keepStackSize();
1174 }
1175:
1176 (
1177 { before(grammarAccess.getArgumentAccess().getVariableOrNodeArgumentParserRuleCall_0()); }
1178 ruleVariableOrNodeArgument
1179 { after(grammarAccess.getArgumentAccess().getVariableOrNodeArgumentParserRuleCall_0()); }
1180 )
1181 |
1182 (
1183 { before(grammarAccess.getArgumentAccess().getConstantArgumentParserRuleCall_1()); }
1184 ruleConstantArgument
1185 { after(grammarAccess.getArgumentAccess().getConstantArgumentParserRuleCall_1()); }
1186 )
1187;
1188finally {
1189 restoreStackSize(stackSize);
1190}
1191
1192rule__Assertion__Alternatives_0
1193 @init {
1194 int stackSize = keepStackSize();
1195 }
1196:
1197 (
1198 { before(grammarAccess.getAssertionAccess().getGroup_0_0()); }
1199 (rule__Assertion__Group_0_0__0)
1200 { after(grammarAccess.getAssertionAccess().getGroup_0_0()); }
1201 )
1202 |
1203 (
1204 { before(grammarAccess.getAssertionAccess().getGroup_0_1()); }
1205 (rule__Assertion__Group_0_1__0)
1206 { after(grammarAccess.getAssertionAccess().getGroup_0_1()); }
1207 )
1208;
1209finally {
1210 restoreStackSize(stackSize);
1211}
1212
1213rule__AssertionArgument__Alternatives
1214 @init {
1215 int stackSize = keepStackSize();
1216 }
1217:
1218 (
1219 { before(grammarAccess.getAssertionArgumentAccess().getNodeAssertionArgumentParserRuleCall_0()); }
1220 ruleNodeAssertionArgument
1221 { after(grammarAccess.getAssertionArgumentAccess().getNodeAssertionArgumentParserRuleCall_0()); }
1222 )
1223 |
1224 (
1225 { before(grammarAccess.getAssertionArgumentAccess().getConstantAssertionArgumentParserRuleCall_1()); }
1226 ruleConstantAssertionArgument
1227 { after(grammarAccess.getAssertionArgumentAccess().getConstantAssertionArgumentParserRuleCall_1()); }
1228 )
1229;
1230finally {
1231 restoreStackSize(stackSize);
1232}
1233
1234rule__Constant__Alternatives
1235 @init {
1236 int stackSize = keepStackSize();
1237 }
1238:
1239 (
1240 { before(grammarAccess.getConstantAccess().getRealConstantParserRuleCall_0()); }
1241 ruleRealConstant
1242 { after(grammarAccess.getConstantAccess().getRealConstantParserRuleCall_0()); }
1243 )
1244 |
1245 (
1246 { before(grammarAccess.getConstantAccess().getIntConstantParserRuleCall_1()); }
1247 ruleIntConstant
1248 { after(grammarAccess.getConstantAccess().getIntConstantParserRuleCall_1()); }
1249 )
1250 |
1251 (
1252 { before(grammarAccess.getConstantAccess().getStringConstantParserRuleCall_2()); }
1253 ruleStringConstant
1254 { after(grammarAccess.getConstantAccess().getStringConstantParserRuleCall_2()); }
1255 )
1256;
1257finally {
1258 restoreStackSize(stackSize);
1259}
1260
1261rule__TypeScope__Alternatives_1
1262 @init {
1263 int stackSize = keepStackSize();
1264 }
1265:
1266 (
1267 { before(grammarAccess.getTypeScopeAccess().getIncrementAssignment_1_0()); }
1268 (rule__TypeScope__IncrementAssignment_1_0)
1269 { after(grammarAccess.getTypeScopeAccess().getIncrementAssignment_1_0()); }
1270 )
1271 |
1272 (
1273 { before(grammarAccess.getTypeScopeAccess().getEqualsSignKeyword_1_1()); }
1274 '='
1275 { after(grammarAccess.getTypeScopeAccess().getEqualsSignKeyword_1_1()); }
1276 )
1277;
1278finally {
1279 restoreStackSize(stackSize);
1280}
1281
1282rule__Multiplicity__Alternatives
1283 @init {
1284 int stackSize = keepStackSize();
1285 }
1286:
1287 (
1288 { before(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); }
1289 ruleUnboundedMultiplicity
1290 { after(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); }
1291 )
1292 |
1293 (
1294 { before(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); }
1295 ruleDefiniteMultiplicity
1296 { after(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); }
1297 )
1298;
1299finally {
1300 restoreStackSize(stackSize);
1301}
1302
1303rule__DefiniteMultiplicity__Alternatives
1304 @init {
1305 int stackSize = keepStackSize();
1306 }
1307:
1308 (
1309 { before(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); }
1310 ruleRangeMultiplicity
1311 { after(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); }
1312 )
1313 |
1314 (
1315 { before(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); }
1316 ruleExactMultiplicity
1317 { after(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); }
1318 )
1319;
1320finally {
1321 restoreStackSize(stackSize);
1322}
1323
1324rule__UpperBound__Alternatives
1325 @init {
1326 int stackSize = keepStackSize();
1327 }
1328:
1329 (
1330 { before(grammarAccess.getUpperBoundAccess().getINTTerminalRuleCall_0()); }
1331 RULE_INT
1332 { after(grammarAccess.getUpperBoundAccess().getINTTerminalRuleCall_0()); }
1333 )
1334 |
1335 (
1336 { before(grammarAccess.getUpperBoundAccess().getAsteriskKeyword_1()); }
1337 '*'
1338 { after(grammarAccess.getUpperBoundAccess().getAsteriskKeyword_1()); }
1339 )
1340;
1341finally {
1342 restoreStackSize(stackSize);
1343}
1344
1345rule__QualifiedName__Alternatives
1346 @init {
1347 int stackSize = keepStackSize();
1348 }
1349:
1350 (
1351 { before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_0()); }
1352 RULE_QUOTED_ID
1353 { after(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_0()); }
1354 )
1355 |
1356 (
1357 { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
1358 (rule__QualifiedName__Group_1__0)
1359 { after(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
1360 )
1361;
1362finally {
1363 restoreStackSize(stackSize);
1364}
1365
1366rule__Identifier__Alternatives
1367 @init {
1368 int stackSize = keepStackSize();
1369 }
1370:
1371 (
1372 { before(grammarAccess.getIdentifierAccess().getIDTerminalRuleCall_0()); }
1373 RULE_ID
1374 { after(grammarAccess.getIdentifierAccess().getIDTerminalRuleCall_0()); }
1375 )
1376 |
1377 (
1378 { before(grammarAccess.getIdentifierAccess().getTrueKeyword_1()); }
1379 'true'
1380 { after(grammarAccess.getIdentifierAccess().getTrueKeyword_1()); }
1381 )
1382 |
1383 (
1384 { before(grammarAccess.getIdentifierAccess().getFalseKeyword_2()); }
1385 'false'
1386 { after(grammarAccess.getIdentifierAccess().getFalseKeyword_2()); }
1387 )
1388;
1389finally {
1390 restoreStackSize(stackSize);
1391}
1392
1393rule__Real__Alternatives_1
1394 @init {
1395 int stackSize = keepStackSize();
1396 }
1397:
1398 (
1399 { before(grammarAccess.getRealAccess().getEXPONENTIALTerminalRuleCall_1_0()); }
1400 RULE_EXPONENTIAL
1401 { after(grammarAccess.getRealAccess().getEXPONENTIALTerminalRuleCall_1_0()); }
1402 )
1403 |
1404 (
1405 { before(grammarAccess.getRealAccess().getGroup_1_1()); }
1406 (rule__Real__Group_1_1__0)
1407 { after(grammarAccess.getRealAccess().getGroup_1_1()); }
1408 )
1409;
1410finally {
1411 restoreStackSize(stackSize);
1412}
1413
1414rule__Real__Alternatives_1_1_2
1415 @init {
1416 int stackSize = keepStackSize();
1417 }
1418:
1419 (
1420 { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1_2_0()); }
1421 RULE_INT
1422 { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1_2_0()); }
1423 )
1424 |
1425 (
1426 { before(grammarAccess.getRealAccess().getEXPONENTIALTerminalRuleCall_1_1_2_1()); }
1427 RULE_EXPONENTIAL
1428 { after(grammarAccess.getRealAccess().getEXPONENTIALTerminalRuleCall_1_1_2_1()); }
1429 )
1430;
1431finally {
1432 restoreStackSize(stackSize);
1433}
1434
1435rule__LogicValue__Alternatives
1436 @init {
1437 int stackSize = keepStackSize();
1438 }
1439:
1440 (
1441 { before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); }
1442 ('true')
1443 { after(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); }
1444 )
1445 |
1446 (
1447 { before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); }
1448 ('false')
1449 { after(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); }
1450 )
1451 |
1452 (
1453 { before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); }
1454 ('unknown')
1455 { after(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); }
1456 )
1457;
1458finally {
1459 restoreStackSize(stackSize);
1460}
1461
1462rule__ShortLogicValue__Alternatives
1463 @init {
1464 int stackSize = keepStackSize();
1465 }
1466:
1467 (
1468 { before(grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0()); }
1469 ('!')
1470 { after(grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0()); }
1471 )
1472 |
1473 (
1474 { before(grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); }
1475 ('?')
1476 { after(grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); }
1477 )
1478;
1479finally {
1480 restoreStackSize(stackSize);
1481}
1482
1483rule__Problem__Group__0
1484 @init {
1485 int stackSize = keepStackSize();
1486 }
1487:
1488 rule__Problem__Group__0__Impl
1489 rule__Problem__Group__1
1490;
1491finally {
1492 restoreStackSize(stackSize);
1493}
1494
1495rule__Problem__Group__0__Impl
1496 @init {
1497 int stackSize = keepStackSize();
1498 }
1499:
1500(
1501 { before(grammarAccess.getProblemAccess().getGroup_0()); }
1502 (rule__Problem__Group_0__0)?
1503 { after(grammarAccess.getProblemAccess().getGroup_0()); }
1504)
1505;
1506finally {
1507 restoreStackSize(stackSize);
1508}
1509
1510rule__Problem__Group__1
1511 @init {
1512 int stackSize = keepStackSize();
1513 }
1514:
1515 rule__Problem__Group__1__Impl
1516;
1517finally {
1518 restoreStackSize(stackSize);
1519}
1520
1521rule__Problem__Group__1__Impl
1522 @init {
1523 int stackSize = keepStackSize();
1524 }
1525:
1526(
1527 { before(grammarAccess.getProblemAccess().getStatementsAssignment_1()); }
1528 (rule__Problem__StatementsAssignment_1)*
1529 { after(grammarAccess.getProblemAccess().getStatementsAssignment_1()); }
1530)
1531;
1532finally {
1533 restoreStackSize(stackSize);
1534}
1535
1536
1537rule__Problem__Group_0__0
1538 @init {
1539 int stackSize = keepStackSize();
1540 }
1541:
1542 rule__Problem__Group_0__0__Impl
1543 rule__Problem__Group_0__1
1544;
1545finally {
1546 restoreStackSize(stackSize);
1547}
1548
1549rule__Problem__Group_0__0__Impl
1550 @init {
1551 int stackSize = keepStackSize();
1552 }
1553:
1554(
1555 { before(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); }
1556 'problem'
1557 { after(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); }
1558)
1559;
1560finally {
1561 restoreStackSize(stackSize);
1562}
1563
1564rule__Problem__Group_0__1
1565 @init {
1566 int stackSize = keepStackSize();
1567 }
1568:
1569 rule__Problem__Group_0__1__Impl
1570 rule__Problem__Group_0__2
1571;
1572finally {
1573 restoreStackSize(stackSize);
1574}
1575
1576rule__Problem__Group_0__1__Impl
1577 @init {
1578 int stackSize = keepStackSize();
1579 }
1580:
1581(
1582 { before(grammarAccess.getProblemAccess().getNameAssignment_0_1()); }
1583 (rule__Problem__NameAssignment_0_1)
1584 { after(grammarAccess.getProblemAccess().getNameAssignment_0_1()); }
1585)
1586;
1587finally {
1588 restoreStackSize(stackSize);
1589}
1590
1591rule__Problem__Group_0__2
1592 @init {
1593 int stackSize = keepStackSize();
1594 }
1595:
1596 rule__Problem__Group_0__2__Impl
1597;
1598finally {
1599 restoreStackSize(stackSize);
1600}
1601
1602rule__Problem__Group_0__2__Impl
1603 @init {
1604 int stackSize = keepStackSize();
1605 }
1606:
1607(
1608 { before(grammarAccess.getProblemAccess().getFullStopKeyword_0_2()); }
1609 '.'
1610 { after(grammarAccess.getProblemAccess().getFullStopKeyword_0_2()); }
1611)
1612;
1613finally {
1614 restoreStackSize(stackSize);
1615}
1616
1617
1618rule__ClassDeclaration__Group__0
1619 @init {
1620 int stackSize = keepStackSize();
1621 }
1622:
1623 rule__ClassDeclaration__Group__0__Impl
1624 rule__ClassDeclaration__Group__1
1625;
1626finally {
1627 restoreStackSize(stackSize);
1628}
1629
1630rule__ClassDeclaration__Group__0__Impl
1631 @init {
1632 int stackSize = keepStackSize();
1633 }
1634:
1635(
1636 { before(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0()); }
1637 (rule__ClassDeclaration__AbstractAssignment_0)?
1638 { after(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0()); }
1639)
1640;
1641finally {
1642 restoreStackSize(stackSize);
1643}
1644
1645rule__ClassDeclaration__Group__1
1646 @init {
1647 int stackSize = keepStackSize();
1648 }
1649:
1650 rule__ClassDeclaration__Group__1__Impl
1651 rule__ClassDeclaration__Group__2
1652;
1653finally {
1654 restoreStackSize(stackSize);
1655}
1656
1657rule__ClassDeclaration__Group__1__Impl
1658 @init {
1659 int stackSize = keepStackSize();
1660 }
1661:
1662(
1663 { before(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); }
1664 'class'
1665 { after(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); }
1666)
1667;
1668finally {
1669 restoreStackSize(stackSize);
1670}
1671
1672rule__ClassDeclaration__Group__2
1673 @init {
1674 int stackSize = keepStackSize();
1675 }
1676:
1677 rule__ClassDeclaration__Group__2__Impl
1678 rule__ClassDeclaration__Group__3
1679;
1680finally {
1681 restoreStackSize(stackSize);
1682}
1683
1684rule__ClassDeclaration__Group__2__Impl
1685 @init {
1686 int stackSize = keepStackSize();
1687 }
1688:
1689(
1690 { before(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); }
1691 (rule__ClassDeclaration__NameAssignment_2)
1692 { after(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); }
1693)
1694;
1695finally {
1696 restoreStackSize(stackSize);
1697}
1698
1699rule__ClassDeclaration__Group__3
1700 @init {
1701 int stackSize = keepStackSize();
1702 }
1703:
1704 rule__ClassDeclaration__Group__3__Impl
1705 rule__ClassDeclaration__Group__4
1706;
1707finally {
1708 restoreStackSize(stackSize);
1709}
1710
1711rule__ClassDeclaration__Group__3__Impl
1712 @init {
1713 int stackSize = keepStackSize();
1714 }
1715:
1716(
1717 { before(grammarAccess.getClassDeclarationAccess().getGroup_3()); }
1718 (rule__ClassDeclaration__Group_3__0)?
1719 { after(grammarAccess.getClassDeclarationAccess().getGroup_3()); }
1720)
1721;
1722finally {
1723 restoreStackSize(stackSize);
1724}
1725
1726rule__ClassDeclaration__Group__4
1727 @init {
1728 int stackSize = keepStackSize();
1729 }
1730:
1731 rule__ClassDeclaration__Group__4__Impl
1732;
1733finally {
1734 restoreStackSize(stackSize);
1735}
1736
1737rule__ClassDeclaration__Group__4__Impl
1738 @init {
1739 int stackSize = keepStackSize();
1740 }
1741:
1742(
1743 { before(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); }
1744 (rule__ClassDeclaration__Alternatives_4)
1745 { after(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); }
1746)
1747;
1748finally {
1749 restoreStackSize(stackSize);
1750}
1751
1752
1753rule__ClassDeclaration__Group_3__0
1754 @init {
1755 int stackSize = keepStackSize();
1756 }
1757:
1758 rule__ClassDeclaration__Group_3__0__Impl
1759 rule__ClassDeclaration__Group_3__1
1760;
1761finally {
1762 restoreStackSize(stackSize);
1763}
1764
1765rule__ClassDeclaration__Group_3__0__Impl
1766 @init {
1767 int stackSize = keepStackSize();
1768 }
1769:
1770(
1771 { before(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); }
1772 'extends'
1773 { after(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); }
1774)
1775;
1776finally {
1777 restoreStackSize(stackSize);
1778}
1779
1780rule__ClassDeclaration__Group_3__1
1781 @init {
1782 int stackSize = keepStackSize();
1783 }
1784:
1785 rule__ClassDeclaration__Group_3__1__Impl
1786 rule__ClassDeclaration__Group_3__2
1787;
1788finally {
1789 restoreStackSize(stackSize);
1790}
1791
1792rule__ClassDeclaration__Group_3__1__Impl
1793 @init {
1794 int stackSize = keepStackSize();
1795 }
1796:
1797(
1798 { before(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_1()); }
1799 (rule__ClassDeclaration__SuperTypesAssignment_3_1)
1800 { after(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_1()); }
1801)
1802;
1803finally {
1804 restoreStackSize(stackSize);
1805}
1806
1807rule__ClassDeclaration__Group_3__2
1808 @init {
1809 int stackSize = keepStackSize();
1810 }
1811:
1812 rule__ClassDeclaration__Group_3__2__Impl
1813;
1814finally {
1815 restoreStackSize(stackSize);
1816}
1817
1818rule__ClassDeclaration__Group_3__2__Impl
1819 @init {
1820 int stackSize = keepStackSize();
1821 }
1822:
1823(
1824 { before(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); }
1825 (rule__ClassDeclaration__Group_3_2__0)*
1826 { after(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); }
1827)
1828;
1829finally {
1830 restoreStackSize(stackSize);
1831}
1832
1833
1834rule__ClassDeclaration__Group_3_2__0
1835 @init {
1836 int stackSize = keepStackSize();
1837 }
1838:
1839 rule__ClassDeclaration__Group_3_2__0__Impl
1840 rule__ClassDeclaration__Group_3_2__1
1841;
1842finally {
1843 restoreStackSize(stackSize);
1844}
1845
1846rule__ClassDeclaration__Group_3_2__0__Impl
1847 @init {
1848 int stackSize = keepStackSize();
1849 }
1850:
1851(
1852 { before(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); }
1853 ','
1854 { after(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); }
1855)
1856;
1857finally {
1858 restoreStackSize(stackSize);
1859}
1860
1861rule__ClassDeclaration__Group_3_2__1
1862 @init {
1863 int stackSize = keepStackSize();
1864 }
1865:
1866 rule__ClassDeclaration__Group_3_2__1__Impl
1867;
1868finally {
1869 restoreStackSize(stackSize);
1870}
1871
1872rule__ClassDeclaration__Group_3_2__1__Impl
1873 @init {
1874 int stackSize = keepStackSize();
1875 }
1876:
1877(
1878 { before(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_2_1()); }
1879 (rule__ClassDeclaration__SuperTypesAssignment_3_2_1)
1880 { after(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_2_1()); }
1881)
1882;
1883finally {
1884 restoreStackSize(stackSize);
1885}
1886
1887
1888rule__ClassDeclaration__Group_4_0__0
1889 @init {
1890 int stackSize = keepStackSize();
1891 }
1892:
1893 rule__ClassDeclaration__Group_4_0__0__Impl
1894 rule__ClassDeclaration__Group_4_0__1
1895;
1896finally {
1897 restoreStackSize(stackSize);
1898}
1899
1900rule__ClassDeclaration__Group_4_0__0__Impl
1901 @init {
1902 int stackSize = keepStackSize();
1903 }
1904:
1905(
1906 { before(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); }
1907 '{'
1908 { after(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); }
1909)
1910;
1911finally {
1912 restoreStackSize(stackSize);
1913}
1914
1915rule__ClassDeclaration__Group_4_0__1
1916 @init {
1917 int stackSize = keepStackSize();
1918 }
1919:
1920 rule__ClassDeclaration__Group_4_0__1__Impl
1921 rule__ClassDeclaration__Group_4_0__2
1922;
1923finally {
1924 restoreStackSize(stackSize);
1925}
1926
1927rule__ClassDeclaration__Group_4_0__1__Impl
1928 @init {
1929 int stackSize = keepStackSize();
1930 }
1931:
1932(
1933 { before(grammarAccess.getClassDeclarationAccess().getGroup_4_0_1()); }
1934 (rule__ClassDeclaration__Group_4_0_1__0)*
1935 { after(grammarAccess.getClassDeclarationAccess().getGroup_4_0_1()); }
1936)
1937;
1938finally {
1939 restoreStackSize(stackSize);
1940}
1941
1942rule__ClassDeclaration__Group_4_0__2
1943 @init {
1944 int stackSize = keepStackSize();
1945 }
1946:
1947 rule__ClassDeclaration__Group_4_0__2__Impl
1948;
1949finally {
1950 restoreStackSize(stackSize);
1951}
1952
1953rule__ClassDeclaration__Group_4_0__2__Impl
1954 @init {
1955 int stackSize = keepStackSize();
1956 }
1957:
1958(
1959 { before(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); }
1960 '}'
1961 { after(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); }
1962)
1963;
1964finally {
1965 restoreStackSize(stackSize);
1966}
1967
1968
1969rule__ClassDeclaration__Group_4_0_1__0
1970 @init {
1971 int stackSize = keepStackSize();
1972 }
1973:
1974 rule__ClassDeclaration__Group_4_0_1__0__Impl
1975 rule__ClassDeclaration__Group_4_0_1__1
1976;
1977finally {
1978 restoreStackSize(stackSize);
1979}
1980
1981rule__ClassDeclaration__Group_4_0_1__0__Impl
1982 @init {
1983 int stackSize = keepStackSize();
1984 }
1985:
1986(
1987 { before(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsAssignment_4_0_1_0()); }
1988 (rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0)
1989 { after(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsAssignment_4_0_1_0()); }
1990)
1991;
1992finally {
1993 restoreStackSize(stackSize);
1994}
1995
1996rule__ClassDeclaration__Group_4_0_1__1
1997 @init {
1998 int stackSize = keepStackSize();
1999 }
2000:
2001 rule__ClassDeclaration__Group_4_0_1__1__Impl
2002;
2003finally {
2004 restoreStackSize(stackSize);
2005}
2006
2007rule__ClassDeclaration__Group_4_0_1__1__Impl
2008 @init {
2009 int stackSize = keepStackSize();
2010 }
2011:
2012(
2013 { before(grammarAccess.getClassDeclarationAccess().getSemicolonKeyword_4_0_1_1()); }
2014 (';')?
2015 { after(grammarAccess.getClassDeclarationAccess().getSemicolonKeyword_4_0_1_1()); }
2016)
2017;
2018finally {
2019 restoreStackSize(stackSize);
2020}
2021
2022
2023rule__EnumDeclaration__Group__0
2024 @init {
2025 int stackSize = keepStackSize();
2026 }
2027:
2028 rule__EnumDeclaration__Group__0__Impl
2029 rule__EnumDeclaration__Group__1
2030;
2031finally {
2032 restoreStackSize(stackSize);
2033}
2034
2035rule__EnumDeclaration__Group__0__Impl
2036 @init {
2037 int stackSize = keepStackSize();
2038 }
2039:
2040(
2041 { before(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); }
2042 'enum'
2043 { after(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); }
2044)
2045;
2046finally {
2047 restoreStackSize(stackSize);
2048}
2049
2050rule__EnumDeclaration__Group__1
2051 @init {
2052 int stackSize = keepStackSize();
2053 }
2054:
2055 rule__EnumDeclaration__Group__1__Impl
2056 rule__EnumDeclaration__Group__2
2057;
2058finally {
2059 restoreStackSize(stackSize);
2060}
2061
2062rule__EnumDeclaration__Group__1__Impl
2063 @init {
2064 int stackSize = keepStackSize();
2065 }
2066:
2067(
2068 { before(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); }
2069 (rule__EnumDeclaration__NameAssignment_1)
2070 { after(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); }
2071)
2072;
2073finally {
2074 restoreStackSize(stackSize);
2075}
2076
2077rule__EnumDeclaration__Group__2
2078 @init {
2079 int stackSize = keepStackSize();
2080 }
2081:
2082 rule__EnumDeclaration__Group__2__Impl
2083;
2084finally {
2085 restoreStackSize(stackSize);
2086}
2087
2088rule__EnumDeclaration__Group__2__Impl
2089 @init {
2090 int stackSize = keepStackSize();
2091 }
2092:
2093(
2094 { before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); }
2095 (rule__EnumDeclaration__Alternatives_2)
2096 { after(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); }
2097)
2098;
2099finally {
2100 restoreStackSize(stackSize);
2101}
2102
2103
2104rule__EnumDeclaration__Group_2_0__0
2105 @init {
2106 int stackSize = keepStackSize();
2107 }
2108:
2109 rule__EnumDeclaration__Group_2_0__0__Impl
2110 rule__EnumDeclaration__Group_2_0__1
2111;
2112finally {
2113 restoreStackSize(stackSize);
2114}
2115
2116rule__EnumDeclaration__Group_2_0__0__Impl
2117 @init {
2118 int stackSize = keepStackSize();
2119 }
2120:
2121(
2122 { before(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); }
2123 '{'
2124 { after(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); }
2125)
2126;
2127finally {
2128 restoreStackSize(stackSize);
2129}
2130
2131rule__EnumDeclaration__Group_2_0__1
2132 @init {
2133 int stackSize = keepStackSize();
2134 }
2135:
2136 rule__EnumDeclaration__Group_2_0__1__Impl
2137 rule__EnumDeclaration__Group_2_0__2
2138;
2139finally {
2140 restoreStackSize(stackSize);
2141}
2142
2143rule__EnumDeclaration__Group_2_0__1__Impl
2144 @init {
2145 int stackSize = keepStackSize();
2146 }
2147:
2148(
2149 { before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); }
2150 (rule__EnumDeclaration__Group_2_0_1__0)?
2151 { after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); }
2152)
2153;
2154finally {
2155 restoreStackSize(stackSize);
2156}
2157
2158rule__EnumDeclaration__Group_2_0__2
2159 @init {
2160 int stackSize = keepStackSize();
2161 }
2162:
2163 rule__EnumDeclaration__Group_2_0__2__Impl
2164;
2165finally {
2166 restoreStackSize(stackSize);
2167}
2168
2169rule__EnumDeclaration__Group_2_0__2__Impl
2170 @init {
2171 int stackSize = keepStackSize();
2172 }
2173:
2174(
2175 { before(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); }
2176 '}'
2177 { after(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); }
2178)
2179;
2180finally {
2181 restoreStackSize(stackSize);
2182}
2183
2184
2185rule__EnumDeclaration__Group_2_0_1__0
2186 @init {
2187 int stackSize = keepStackSize();
2188 }
2189:
2190 rule__EnumDeclaration__Group_2_0_1__0__Impl
2191 rule__EnumDeclaration__Group_2_0_1__1
2192;
2193finally {
2194 restoreStackSize(stackSize);
2195}
2196
2197rule__EnumDeclaration__Group_2_0_1__0__Impl
2198 @init {
2199 int stackSize = keepStackSize();
2200 }
2201:
2202(
2203 { before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); }
2204 (rule__EnumDeclaration__LiteralsAssignment_2_0_1_0)
2205 { after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); }
2206)
2207;
2208finally {
2209 restoreStackSize(stackSize);
2210}
2211
2212rule__EnumDeclaration__Group_2_0_1__1
2213 @init {
2214 int stackSize = keepStackSize();
2215 }
2216:
2217 rule__EnumDeclaration__Group_2_0_1__1__Impl
2218 rule__EnumDeclaration__Group_2_0_1__2
2219;
2220finally {
2221 restoreStackSize(stackSize);
2222}
2223
2224rule__EnumDeclaration__Group_2_0_1__1__Impl
2225 @init {
2226 int stackSize = keepStackSize();
2227 }
2228:
2229(
2230 { before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); }
2231 (rule__EnumDeclaration__Group_2_0_1_1__0)*
2232 { after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); }
2233)
2234;
2235finally {
2236 restoreStackSize(stackSize);
2237}
2238
2239rule__EnumDeclaration__Group_2_0_1__2
2240 @init {
2241 int stackSize = keepStackSize();
2242 }
2243:
2244 rule__EnumDeclaration__Group_2_0_1__2__Impl
2245;
2246finally {
2247 restoreStackSize(stackSize);
2248}
2249
2250rule__EnumDeclaration__Group_2_0_1__2__Impl
2251 @init {
2252 int stackSize = keepStackSize();
2253 }
2254:
2255(
2256 { before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2_0_1_2()); }
2257 (rule__EnumDeclaration__Alternatives_2_0_1_2)?
2258 { after(grammarAccess.getEnumDeclarationAccess().getAlternatives_2_0_1_2()); }
2259)
2260;
2261finally {
2262 restoreStackSize(stackSize);
2263}
2264
2265
2266rule__EnumDeclaration__Group_2_0_1_1__0
2267 @init {
2268 int stackSize = keepStackSize();
2269 }
2270:
2271 rule__EnumDeclaration__Group_2_0_1_1__0__Impl
2272 rule__EnumDeclaration__Group_2_0_1_1__1
2273;
2274finally {
2275 restoreStackSize(stackSize);
2276}
2277
2278rule__EnumDeclaration__Group_2_0_1_1__0__Impl
2279 @init {
2280 int stackSize = keepStackSize();
2281 }
2282:
2283(
2284 { before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); }
2285 ','
2286 { after(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); }
2287)
2288;
2289finally {
2290 restoreStackSize(stackSize);
2291}
2292
2293rule__EnumDeclaration__Group_2_0_1_1__1
2294 @init {
2295 int stackSize = keepStackSize();
2296 }
2297:
2298 rule__EnumDeclaration__Group_2_0_1_1__1__Impl
2299;
2300finally {
2301 restoreStackSize(stackSize);
2302}
2303
2304rule__EnumDeclaration__Group_2_0_1_1__1__Impl
2305 @init {
2306 int stackSize = keepStackSize();
2307 }
2308:
2309(
2310 { before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); }
2311 (rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1)
2312 { after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); }
2313)
2314;
2315finally {
2316 restoreStackSize(stackSize);
2317}
2318
2319
2320rule__ReferenceDeclaration__Group__0
2321 @init {
2322 int stackSize = keepStackSize();
2323 }
2324:
2325 rule__ReferenceDeclaration__Group__0__Impl
2326 rule__ReferenceDeclaration__Group__1
2327;
2328finally {
2329 restoreStackSize(stackSize);
2330}
2331
2332rule__ReferenceDeclaration__Group__0__Impl
2333 @init {
2334 int stackSize = keepStackSize();
2335 }
2336:
2337(
2338 { before(grammarAccess.getReferenceDeclarationAccess().getAlternatives_0()); }
2339 (rule__ReferenceDeclaration__Alternatives_0)?
2340 { after(grammarAccess.getReferenceDeclarationAccess().getAlternatives_0()); }
2341)
2342;
2343finally {
2344 restoreStackSize(stackSize);
2345}
2346
2347rule__ReferenceDeclaration__Group__1
2348 @init {
2349 int stackSize = keepStackSize();
2350 }
2351:
2352 rule__ReferenceDeclaration__Group__1__Impl
2353 rule__ReferenceDeclaration__Group__2
2354;
2355finally {
2356 restoreStackSize(stackSize);
2357}
2358
2359rule__ReferenceDeclaration__Group__1__Impl
2360 @init {
2361 int stackSize = keepStackSize();
2362 }
2363:
2364(
2365 { before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeAssignment_1()); }
2366 (rule__ReferenceDeclaration__ReferenceTypeAssignment_1)
2367 { after(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeAssignment_1()); }
2368)
2369;
2370finally {
2371 restoreStackSize(stackSize);
2372}
2373
2374rule__ReferenceDeclaration__Group__2
2375 @init {
2376 int stackSize = keepStackSize();
2377 }
2378:
2379 rule__ReferenceDeclaration__Group__2__Impl
2380 rule__ReferenceDeclaration__Group__3
2381;
2382finally {
2383 restoreStackSize(stackSize);
2384}
2385
2386rule__ReferenceDeclaration__Group__2__Impl
2387 @init {
2388 int stackSize = keepStackSize();
2389 }
2390:
2391(
2392 { before(grammarAccess.getReferenceDeclarationAccess().getGroup_2()); }
2393 (rule__ReferenceDeclaration__Group_2__0)?
2394 { after(grammarAccess.getReferenceDeclarationAccess().getGroup_2()); }
2395)
2396;
2397finally {
2398 restoreStackSize(stackSize);
2399}
2400
2401rule__ReferenceDeclaration__Group__3
2402 @init {
2403 int stackSize = keepStackSize();
2404 }
2405:
2406 rule__ReferenceDeclaration__Group__3__Impl
2407 rule__ReferenceDeclaration__Group__4
2408;
2409finally {
2410 restoreStackSize(stackSize);
2411}
2412
2413rule__ReferenceDeclaration__Group__3__Impl
2414 @init {
2415 int stackSize = keepStackSize();
2416 }
2417:
2418(
2419 { before(grammarAccess.getReferenceDeclarationAccess().getNameAssignment_3()); }
2420 (rule__ReferenceDeclaration__NameAssignment_3)
2421 { after(grammarAccess.getReferenceDeclarationAccess().getNameAssignment_3()); }
2422)
2423;
2424finally {
2425 restoreStackSize(stackSize);
2426}
2427
2428rule__ReferenceDeclaration__Group__4
2429 @init {
2430 int stackSize = keepStackSize();
2431 }
2432:
2433 rule__ReferenceDeclaration__Group__4__Impl
2434;
2435finally {
2436 restoreStackSize(stackSize);
2437}
2438
2439rule__ReferenceDeclaration__Group__4__Impl
2440 @init {
2441 int stackSize = keepStackSize();
2442 }
2443:
2444(
2445 { before(grammarAccess.getReferenceDeclarationAccess().getGroup_4()); }
2446 (rule__ReferenceDeclaration__Group_4__0)?
2447 { after(grammarAccess.getReferenceDeclarationAccess().getGroup_4()); }
2448)
2449;
2450finally {
2451 restoreStackSize(stackSize);
2452}
2453
2454
2455rule__ReferenceDeclaration__Group_2__0
2456 @init {
2457 int stackSize = keepStackSize();
2458 }
2459:
2460 rule__ReferenceDeclaration__Group_2__0__Impl
2461 rule__ReferenceDeclaration__Group_2__1
2462;
2463finally {
2464 restoreStackSize(stackSize);
2465}
2466
2467rule__ReferenceDeclaration__Group_2__0__Impl
2468 @init {
2469 int stackSize = keepStackSize();
2470 }
2471:
2472(
2473 { before(grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); }
2474 '['
2475 { after(grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); }
2476)
2477;
2478finally {
2479 restoreStackSize(stackSize);
2480}
2481
2482rule__ReferenceDeclaration__Group_2__1
2483 @init {
2484 int stackSize = keepStackSize();
2485 }
2486:
2487 rule__ReferenceDeclaration__Group_2__1__Impl
2488 rule__ReferenceDeclaration__Group_2__2
2489;
2490finally {
2491 restoreStackSize(stackSize);
2492}
2493
2494rule__ReferenceDeclaration__Group_2__1__Impl
2495 @init {
2496 int stackSize = keepStackSize();
2497 }
2498:
2499(
2500 { before(grammarAccess.getReferenceDeclarationAccess().getMultiplicityAssignment_2_1()); }
2501 (rule__ReferenceDeclaration__MultiplicityAssignment_2_1)
2502 { after(grammarAccess.getReferenceDeclarationAccess().getMultiplicityAssignment_2_1()); }
2503)
2504;
2505finally {
2506 restoreStackSize(stackSize);
2507}
2508
2509rule__ReferenceDeclaration__Group_2__2
2510 @init {
2511 int stackSize = keepStackSize();
2512 }
2513:
2514 rule__ReferenceDeclaration__Group_2__2__Impl
2515;
2516finally {
2517 restoreStackSize(stackSize);
2518}
2519
2520rule__ReferenceDeclaration__Group_2__2__Impl
2521 @init {
2522 int stackSize = keepStackSize();
2523 }
2524:
2525(
2526 { before(grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); }
2527 ']'
2528 { after(grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); }
2529)
2530;
2531finally {
2532 restoreStackSize(stackSize);
2533}
2534
2535
2536rule__ReferenceDeclaration__Group_4__0
2537 @init {
2538 int stackSize = keepStackSize();
2539 }
2540:
2541 rule__ReferenceDeclaration__Group_4__0__Impl
2542 rule__ReferenceDeclaration__Group_4__1
2543;
2544finally {
2545 restoreStackSize(stackSize);
2546}
2547
2548rule__ReferenceDeclaration__Group_4__0__Impl
2549 @init {
2550 int stackSize = keepStackSize();
2551 }
2552:
2553(
2554 { before(grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); }
2555 'opposite'
2556 { after(grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); }
2557)
2558;
2559finally {
2560 restoreStackSize(stackSize);
2561}
2562
2563rule__ReferenceDeclaration__Group_4__1
2564 @init {
2565 int stackSize = keepStackSize();
2566 }
2567:
2568 rule__ReferenceDeclaration__Group_4__1__Impl
2569;
2570finally {
2571 restoreStackSize(stackSize);
2572}
2573
2574rule__ReferenceDeclaration__Group_4__1__Impl
2575 @init {
2576 int stackSize = keepStackSize();
2577 }
2578:
2579(
2580 { before(grammarAccess.getReferenceDeclarationAccess().getOppositeAssignment_4_1()); }
2581 (rule__ReferenceDeclaration__OppositeAssignment_4_1)
2582 { after(grammarAccess.getReferenceDeclarationAccess().getOppositeAssignment_4_1()); }
2583)
2584;
2585finally {
2586 restoreStackSize(stackSize);
2587}
2588
2589
2590rule__PredicateDefinition__Group__0
2591 @init {
2592 int stackSize = keepStackSize();
2593 }
2594:
2595 rule__PredicateDefinition__Group__0__Impl
2596 rule__PredicateDefinition__Group__1
2597;
2598finally {
2599 restoreStackSize(stackSize);
2600}
2601
2602rule__PredicateDefinition__Group__0__Impl
2603 @init {
2604 int stackSize = keepStackSize();
2605 }
2606:
2607(
2608 { before(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); }
2609 (rule__PredicateDefinition__Alternatives_0)
2610 { after(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); }
2611)
2612;
2613finally {
2614 restoreStackSize(stackSize);
2615}
2616
2617rule__PredicateDefinition__Group__1
2618 @init {
2619 int stackSize = keepStackSize();
2620 }
2621:
2622 rule__PredicateDefinition__Group__1__Impl
2623 rule__PredicateDefinition__Group__2
2624;
2625finally {
2626 restoreStackSize(stackSize);
2627}
2628
2629rule__PredicateDefinition__Group__1__Impl
2630 @init {
2631 int stackSize = keepStackSize();
2632 }
2633:
2634(
2635 { before(grammarAccess.getPredicateDefinitionAccess().getNameAssignment_1()); }
2636 (rule__PredicateDefinition__NameAssignment_1)
2637 { after(grammarAccess.getPredicateDefinitionAccess().getNameAssignment_1()); }
2638)
2639;
2640finally {
2641 restoreStackSize(stackSize);
2642}
2643
2644rule__PredicateDefinition__Group__2
2645 @init {
2646 int stackSize = keepStackSize();
2647 }
2648:
2649 rule__PredicateDefinition__Group__2__Impl
2650 rule__PredicateDefinition__Group__3
2651;
2652finally {
2653 restoreStackSize(stackSize);
2654}
2655
2656rule__PredicateDefinition__Group__2__Impl
2657 @init {
2658 int stackSize = keepStackSize();
2659 }
2660:
2661(
2662 { before(grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); }
2663 '('
2664 { after(grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); }
2665)
2666;
2667finally {
2668 restoreStackSize(stackSize);
2669}
2670
2671rule__PredicateDefinition__Group__3
2672 @init {
2673 int stackSize = keepStackSize();
2674 }
2675:
2676 rule__PredicateDefinition__Group__3__Impl
2677 rule__PredicateDefinition__Group__4
2678;
2679finally {
2680 restoreStackSize(stackSize);
2681}
2682
2683rule__PredicateDefinition__Group__3__Impl
2684 @init {
2685 int stackSize = keepStackSize();
2686 }
2687:
2688(
2689 { before(grammarAccess.getPredicateDefinitionAccess().getGroup_3()); }
2690 (rule__PredicateDefinition__Group_3__0)?
2691 { after(grammarAccess.getPredicateDefinitionAccess().getGroup_3()); }
2692)
2693;
2694finally {
2695 restoreStackSize(stackSize);
2696}
2697
2698rule__PredicateDefinition__Group__4
2699 @init {
2700 int stackSize = keepStackSize();
2701 }
2702:
2703 rule__PredicateDefinition__Group__4__Impl
2704 rule__PredicateDefinition__Group__5
2705;
2706finally {
2707 restoreStackSize(stackSize);
2708}
2709
2710rule__PredicateDefinition__Group__4__Impl
2711 @init {
2712 int stackSize = keepStackSize();
2713 }
2714:
2715(
2716 { before(grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); }
2717 ')'
2718 { after(grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); }
2719)
2720;
2721finally {
2722 restoreStackSize(stackSize);
2723}
2724
2725rule__PredicateDefinition__Group__5
2726 @init {
2727 int stackSize = keepStackSize();
2728 }
2729:
2730 rule__PredicateDefinition__Group__5__Impl
2731 rule__PredicateDefinition__Group__6
2732;
2733finally {
2734 restoreStackSize(stackSize);
2735}
2736
2737rule__PredicateDefinition__Group__5__Impl
2738 @init {
2739 int stackSize = keepStackSize();
2740 }
2741:
2742(
2743 { before(grammarAccess.getPredicateDefinitionAccess().getGroup_5()); }
2744 (rule__PredicateDefinition__Group_5__0)?
2745 { after(grammarAccess.getPredicateDefinitionAccess().getGroup_5()); }
2746)
2747;
2748finally {
2749 restoreStackSize(stackSize);
2750}
2751
2752rule__PredicateDefinition__Group__6
2753 @init {
2754 int stackSize = keepStackSize();
2755 }
2756:
2757 rule__PredicateDefinition__Group__6__Impl
2758;
2759finally {
2760 restoreStackSize(stackSize);
2761}
2762
2763rule__PredicateDefinition__Group__6__Impl
2764 @init {
2765 int stackSize = keepStackSize();
2766 }
2767:
2768(
2769 { before(grammarAccess.getPredicateDefinitionAccess().getFullStopKeyword_6()); }
2770 '.'
2771 { after(grammarAccess.getPredicateDefinitionAccess().getFullStopKeyword_6()); }
2772)
2773;
2774finally {
2775 restoreStackSize(stackSize);
2776}
2777
2778
2779rule__PredicateDefinition__Group_0_0__0
2780 @init {
2781 int stackSize = keepStackSize();
2782 }
2783:
2784 rule__PredicateDefinition__Group_0_0__0__Impl
2785 rule__PredicateDefinition__Group_0_0__1
2786;
2787finally {
2788 restoreStackSize(stackSize);
2789}
2790
2791rule__PredicateDefinition__Group_0_0__0__Impl
2792 @init {
2793 int stackSize = keepStackSize();
2794 }
2795:
2796(
2797 { before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_0()); }
2798 (rule__PredicateDefinition__ErrorAssignment_0_0_0)
2799 { after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_0()); }
2800)
2801;
2802finally {
2803 restoreStackSize(stackSize);
2804}
2805
2806rule__PredicateDefinition__Group_0_0__1
2807 @init {
2808 int stackSize = keepStackSize();
2809 }
2810:
2811 rule__PredicateDefinition__Group_0_0__1__Impl
2812;
2813finally {
2814 restoreStackSize(stackSize);
2815}
2816
2817rule__PredicateDefinition__Group_0_0__1__Impl
2818 @init {
2819 int stackSize = keepStackSize();
2820 }
2821:
2822(
2823 { before(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_0_1()); }
2824 ('pred')?
2825 { after(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_0_1()); }
2826)
2827;
2828finally {
2829 restoreStackSize(stackSize);
2830}
2831
2832
2833rule__PredicateDefinition__Group_3__0
2834 @init {
2835 int stackSize = keepStackSize();
2836 }
2837:
2838 rule__PredicateDefinition__Group_3__0__Impl
2839 rule__PredicateDefinition__Group_3__1
2840;
2841finally {
2842 restoreStackSize(stackSize);
2843}
2844
2845rule__PredicateDefinition__Group_3__0__Impl
2846 @init {
2847 int stackSize = keepStackSize();
2848 }
2849:
2850(
2851 { before(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_0()); }
2852 (rule__PredicateDefinition__ParametersAssignment_3_0)
2853 { after(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_0()); }
2854)
2855;
2856finally {
2857 restoreStackSize(stackSize);
2858}
2859
2860rule__PredicateDefinition__Group_3__1
2861 @init {
2862 int stackSize = keepStackSize();
2863 }
2864:
2865 rule__PredicateDefinition__Group_3__1__Impl
2866;
2867finally {
2868 restoreStackSize(stackSize);
2869}
2870
2871rule__PredicateDefinition__Group_3__1__Impl
2872 @init {
2873 int stackSize = keepStackSize();
2874 }
2875:
2876(
2877 { before(grammarAccess.getPredicateDefinitionAccess().getGroup_3_1()); }
2878 (rule__PredicateDefinition__Group_3_1__0)*
2879 { after(grammarAccess.getPredicateDefinitionAccess().getGroup_3_1()); }
2880)
2881;
2882finally {
2883 restoreStackSize(stackSize);
2884}
2885
2886
2887rule__PredicateDefinition__Group_3_1__0
2888 @init {
2889 int stackSize = keepStackSize();
2890 }
2891:
2892 rule__PredicateDefinition__Group_3_1__0__Impl
2893 rule__PredicateDefinition__Group_3_1__1
2894;
2895finally {
2896 restoreStackSize(stackSize);
2897}
2898
2899rule__PredicateDefinition__Group_3_1__0__Impl
2900 @init {
2901 int stackSize = keepStackSize();
2902 }
2903:
2904(
2905 { before(grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); }
2906 ','
2907 { after(grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); }
2908)
2909;
2910finally {
2911 restoreStackSize(stackSize);
2912}
2913
2914rule__PredicateDefinition__Group_3_1__1
2915 @init {
2916 int stackSize = keepStackSize();
2917 }
2918:
2919 rule__PredicateDefinition__Group_3_1__1__Impl
2920;
2921finally {
2922 restoreStackSize(stackSize);
2923}
2924
2925rule__PredicateDefinition__Group_3_1__1__Impl
2926 @init {
2927 int stackSize = keepStackSize();
2928 }
2929:
2930(
2931 { before(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_1_1()); }
2932 (rule__PredicateDefinition__ParametersAssignment_3_1_1)
2933 { after(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_1_1()); }
2934)
2935;
2936finally {
2937 restoreStackSize(stackSize);
2938}
2939
2940
2941rule__PredicateDefinition__Group_5__0
2942 @init {
2943 int stackSize = keepStackSize();
2944 }
2945:
2946 rule__PredicateDefinition__Group_5__0__Impl
2947 rule__PredicateDefinition__Group_5__1
2948;
2949finally {
2950 restoreStackSize(stackSize);
2951}
2952
2953rule__PredicateDefinition__Group_5__0__Impl
2954 @init {
2955 int stackSize = keepStackSize();
2956 }
2957:
2958(
2959 { before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); }
2960 ':-'
2961 { after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); }
2962)
2963;
2964finally {
2965 restoreStackSize(stackSize);
2966}
2967
2968rule__PredicateDefinition__Group_5__1
2969 @init {
2970 int stackSize = keepStackSize();
2971 }
2972:
2973 rule__PredicateDefinition__Group_5__1__Impl
2974 rule__PredicateDefinition__Group_5__2
2975;
2976finally {
2977 restoreStackSize(stackSize);
2978}
2979
2980rule__PredicateDefinition__Group_5__1__Impl
2981 @init {
2982 int stackSize = keepStackSize();
2983 }
2984:
2985(
2986 { before(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_1()); }
2987 (rule__PredicateDefinition__BodiesAssignment_5_1)
2988 { after(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_1()); }
2989)
2990;
2991finally {
2992 restoreStackSize(stackSize);
2993}
2994
2995rule__PredicateDefinition__Group_5__2
2996 @init {
2997 int stackSize = keepStackSize();
2998 }
2999:
3000 rule__PredicateDefinition__Group_5__2__Impl
3001;
3002finally {
3003 restoreStackSize(stackSize);
3004}
3005
3006rule__PredicateDefinition__Group_5__2__Impl
3007 @init {
3008 int stackSize = keepStackSize();
3009 }
3010:
3011(
3012 { before(grammarAccess.getPredicateDefinitionAccess().getGroup_5_2()); }
3013 (rule__PredicateDefinition__Group_5_2__0)*
3014 { after(grammarAccess.getPredicateDefinitionAccess().getGroup_5_2()); }
3015)
3016;
3017finally {
3018 restoreStackSize(stackSize);
3019}
3020
3021
3022rule__PredicateDefinition__Group_5_2__0
3023 @init {
3024 int stackSize = keepStackSize();
3025 }
3026:
3027 rule__PredicateDefinition__Group_5_2__0__Impl
3028 rule__PredicateDefinition__Group_5_2__1
3029;
3030finally {
3031 restoreStackSize(stackSize);
3032}
3033
3034rule__PredicateDefinition__Group_5_2__0__Impl
3035 @init {
3036 int stackSize = keepStackSize();
3037 }
3038:
3039(
3040 { before(grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); }
3041 ';'
3042 { after(grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); }
3043)
3044;
3045finally {
3046 restoreStackSize(stackSize);
3047}
3048
3049rule__PredicateDefinition__Group_5_2__1
3050 @init {
3051 int stackSize = keepStackSize();
3052 }
3053:
3054 rule__PredicateDefinition__Group_5_2__1__Impl
3055;
3056finally {
3057 restoreStackSize(stackSize);
3058}
3059
3060rule__PredicateDefinition__Group_5_2__1__Impl
3061 @init {
3062 int stackSize = keepStackSize();
3063 }
3064:
3065(
3066 { before(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_2_1()); }
3067 (rule__PredicateDefinition__BodiesAssignment_5_2_1)
3068 { after(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_2_1()); }
3069)
3070;
3071finally {
3072 restoreStackSize(stackSize);
3073}
3074
3075
3076rule__Parameter__Group__0
3077 @init {
3078 int stackSize = keepStackSize();
3079 }
3080:
3081 rule__Parameter__Group__0__Impl
3082 rule__Parameter__Group__1
3083;
3084finally {
3085 restoreStackSize(stackSize);
3086}
3087
3088rule__Parameter__Group__0__Impl
3089 @init {
3090 int stackSize = keepStackSize();
3091 }
3092:
3093(
3094 { before(grammarAccess.getParameterAccess().getParameterTypeAssignment_0()); }
3095 (rule__Parameter__ParameterTypeAssignment_0)?
3096 { after(grammarAccess.getParameterAccess().getParameterTypeAssignment_0()); }
3097)
3098;
3099finally {
3100 restoreStackSize(stackSize);
3101}
3102
3103rule__Parameter__Group__1
3104 @init {
3105 int stackSize = keepStackSize();
3106 }
3107:
3108 rule__Parameter__Group__1__Impl
3109;
3110finally {
3111 restoreStackSize(stackSize);
3112}
3113
3114rule__Parameter__Group__1__Impl
3115 @init {
3116 int stackSize = keepStackSize();
3117 }
3118:
3119(
3120 { before(grammarAccess.getParameterAccess().getNameAssignment_1()); }
3121 (rule__Parameter__NameAssignment_1)
3122 { after(grammarAccess.getParameterAccess().getNameAssignment_1()); }
3123)
3124;
3125finally {
3126 restoreStackSize(stackSize);
3127}
3128
3129
3130rule__Conjunction__Group__0
3131 @init {
3132 int stackSize = keepStackSize();
3133 }
3134:
3135 rule__Conjunction__Group__0__Impl
3136 rule__Conjunction__Group__1
3137;
3138finally {
3139 restoreStackSize(stackSize);
3140}
3141
3142rule__Conjunction__Group__0__Impl
3143 @init {
3144 int stackSize = keepStackSize();
3145 }
3146:
3147(
3148 { before(grammarAccess.getConjunctionAccess().getLiteralsAssignment_0()); }
3149 (rule__Conjunction__LiteralsAssignment_0)
3150 { after(grammarAccess.getConjunctionAccess().getLiteralsAssignment_0()); }
3151)
3152;
3153finally {
3154 restoreStackSize(stackSize);
3155}
3156
3157rule__Conjunction__Group__1
3158 @init {
3159 int stackSize = keepStackSize();
3160 }
3161:
3162 rule__Conjunction__Group__1__Impl
3163;
3164finally {
3165 restoreStackSize(stackSize);
3166}
3167
3168rule__Conjunction__Group__1__Impl
3169 @init {
3170 int stackSize = keepStackSize();
3171 }
3172:
3173(
3174 { before(grammarAccess.getConjunctionAccess().getGroup_1()); }
3175 (rule__Conjunction__Group_1__0)*
3176 { after(grammarAccess.getConjunctionAccess().getGroup_1()); }
3177)
3178;
3179finally {
3180 restoreStackSize(stackSize);
3181}
3182
3183
3184rule__Conjunction__Group_1__0
3185 @init {
3186 int stackSize = keepStackSize();
3187 }
3188:
3189 rule__Conjunction__Group_1__0__Impl
3190 rule__Conjunction__Group_1__1
3191;
3192finally {
3193 restoreStackSize(stackSize);
3194}
3195
3196rule__Conjunction__Group_1__0__Impl
3197 @init {
3198 int stackSize = keepStackSize();
3199 }
3200:
3201(
3202 { before(grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); }
3203 ','
3204 { after(grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); }
3205)
3206;
3207finally {
3208 restoreStackSize(stackSize);
3209}
3210
3211rule__Conjunction__Group_1__1
3212 @init {
3213 int stackSize = keepStackSize();
3214 }
3215:
3216 rule__Conjunction__Group_1__1__Impl
3217;
3218finally {
3219 restoreStackSize(stackSize);
3220}
3221
3222rule__Conjunction__Group_1__1__Impl
3223 @init {
3224 int stackSize = keepStackSize();
3225 }
3226:
3227(
3228 { before(grammarAccess.getConjunctionAccess().getLiteralsAssignment_1_1()); }
3229 (rule__Conjunction__LiteralsAssignment_1_1)
3230 { after(grammarAccess.getConjunctionAccess().getLiteralsAssignment_1_1()); }
3231)
3232;
3233finally {
3234 restoreStackSize(stackSize);
3235}
3236
3237
3238rule__NegativeLiteral__Group__0
3239 @init {
3240 int stackSize = keepStackSize();
3241 }
3242:
3243 rule__NegativeLiteral__Group__0__Impl
3244 rule__NegativeLiteral__Group__1
3245;
3246finally {
3247 restoreStackSize(stackSize);
3248}
3249
3250rule__NegativeLiteral__Group__0__Impl
3251 @init {
3252 int stackSize = keepStackSize();
3253 }
3254:
3255(
3256 { before(grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); }
3257 '!'
3258 { after(grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); }
3259)
3260;
3261finally {
3262 restoreStackSize(stackSize);
3263}
3264
3265rule__NegativeLiteral__Group__1
3266 @init {
3267 int stackSize = keepStackSize();
3268 }
3269:
3270 rule__NegativeLiteral__Group__1__Impl
3271;
3272finally {
3273 restoreStackSize(stackSize);
3274}
3275
3276rule__NegativeLiteral__Group__1__Impl
3277 @init {
3278 int stackSize = keepStackSize();
3279 }
3280:
3281(
3282 { before(grammarAccess.getNegativeLiteralAccess().getAtomAssignment_1()); }
3283 (rule__NegativeLiteral__AtomAssignment_1)
3284 { after(grammarAccess.getNegativeLiteralAccess().getAtomAssignment_1()); }
3285)
3286;
3287finally {
3288 restoreStackSize(stackSize);
3289}
3290
3291
3292rule__Atom__Group__0
3293 @init {
3294 int stackSize = keepStackSize();
3295 }
3296:
3297 rule__Atom__Group__0__Impl
3298 rule__Atom__Group__1
3299;
3300finally {
3301 restoreStackSize(stackSize);
3302}
3303
3304rule__Atom__Group__0__Impl
3305 @init {
3306 int stackSize = keepStackSize();
3307 }
3308:
3309(
3310 { before(grammarAccess.getAtomAccess().getRelationAssignment_0()); }
3311 (rule__Atom__RelationAssignment_0)
3312 { after(grammarAccess.getAtomAccess().getRelationAssignment_0()); }
3313)
3314;
3315finally {
3316 restoreStackSize(stackSize);
3317}
3318
3319rule__Atom__Group__1
3320 @init {
3321 int stackSize = keepStackSize();
3322 }
3323:
3324 rule__Atom__Group__1__Impl
3325 rule__Atom__Group__2
3326;
3327finally {
3328 restoreStackSize(stackSize);
3329}
3330
3331rule__Atom__Group__1__Impl
3332 @init {
3333 int stackSize = keepStackSize();
3334 }
3335:
3336(
3337 { before(grammarAccess.getAtomAccess().getTransitiveClosureAssignment_1()); }
3338 (rule__Atom__TransitiveClosureAssignment_1)?
3339 { after(grammarAccess.getAtomAccess().getTransitiveClosureAssignment_1()); }
3340)
3341;
3342finally {
3343 restoreStackSize(stackSize);
3344}
3345
3346rule__Atom__Group__2
3347 @init {
3348 int stackSize = keepStackSize();
3349 }
3350:
3351 rule__Atom__Group__2__Impl
3352 rule__Atom__Group__3
3353;
3354finally {
3355 restoreStackSize(stackSize);
3356}
3357
3358rule__Atom__Group__2__Impl
3359 @init {
3360 int stackSize = keepStackSize();
3361 }
3362:
3363(
3364 { before(grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); }
3365 '('
3366 { after(grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); }
3367)
3368;
3369finally {
3370 restoreStackSize(stackSize);
3371}
3372
3373rule__Atom__Group__3
3374 @init {
3375 int stackSize = keepStackSize();
3376 }
3377:
3378 rule__Atom__Group__3__Impl
3379 rule__Atom__Group__4
3380;
3381finally {
3382 restoreStackSize(stackSize);
3383}
3384
3385rule__Atom__Group__3__Impl
3386 @init {
3387 int stackSize = keepStackSize();
3388 }
3389:
3390(
3391 { before(grammarAccess.getAtomAccess().getGroup_3()); }
3392 (rule__Atom__Group_3__0)?
3393 { after(grammarAccess.getAtomAccess().getGroup_3()); }
3394)
3395;
3396finally {
3397 restoreStackSize(stackSize);
3398}
3399
3400rule__Atom__Group__4
3401 @init {
3402 int stackSize = keepStackSize();
3403 }
3404:
3405 rule__Atom__Group__4__Impl
3406;
3407finally {
3408 restoreStackSize(stackSize);
3409}
3410
3411rule__Atom__Group__4__Impl
3412 @init {
3413 int stackSize = keepStackSize();
3414 }
3415:
3416(
3417 { before(grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); }
3418 ')'
3419 { after(grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); }
3420)
3421;
3422finally {
3423 restoreStackSize(stackSize);
3424}
3425
3426
3427rule__Atom__Group_3__0
3428 @init {
3429 int stackSize = keepStackSize();
3430 }
3431:
3432 rule__Atom__Group_3__0__Impl
3433 rule__Atom__Group_3__1
3434;
3435finally {
3436 restoreStackSize(stackSize);
3437}
3438
3439rule__Atom__Group_3__0__Impl
3440 @init {
3441 int stackSize = keepStackSize();
3442 }
3443:
3444(
3445 { before(grammarAccess.getAtomAccess().getArgumentsAssignment_3_0()); }
3446 (rule__Atom__ArgumentsAssignment_3_0)
3447 { after(grammarAccess.getAtomAccess().getArgumentsAssignment_3_0()); }
3448)
3449;
3450finally {
3451 restoreStackSize(stackSize);
3452}
3453
3454rule__Atom__Group_3__1
3455 @init {
3456 int stackSize = keepStackSize();
3457 }
3458:
3459 rule__Atom__Group_3__1__Impl
3460;
3461finally {
3462 restoreStackSize(stackSize);
3463}
3464
3465rule__Atom__Group_3__1__Impl
3466 @init {
3467 int stackSize = keepStackSize();
3468 }
3469:
3470(
3471 { before(grammarAccess.getAtomAccess().getGroup_3_1()); }
3472 (rule__Atom__Group_3_1__0)*
3473 { after(grammarAccess.getAtomAccess().getGroup_3_1()); }
3474)
3475;
3476finally {
3477 restoreStackSize(stackSize);
3478}
3479
3480
3481rule__Atom__Group_3_1__0
3482 @init {
3483 int stackSize = keepStackSize();
3484 }
3485:
3486 rule__Atom__Group_3_1__0__Impl
3487 rule__Atom__Group_3_1__1
3488;
3489finally {
3490 restoreStackSize(stackSize);
3491}
3492
3493rule__Atom__Group_3_1__0__Impl
3494 @init {
3495 int stackSize = keepStackSize();
3496 }
3497:
3498(
3499 { before(grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); }
3500 ','
3501 { after(grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); }
3502)
3503;
3504finally {
3505 restoreStackSize(stackSize);
3506}
3507
3508rule__Atom__Group_3_1__1
3509 @init {
3510 int stackSize = keepStackSize();
3511 }
3512:
3513 rule__Atom__Group_3_1__1__Impl
3514;
3515finally {
3516 restoreStackSize(stackSize);
3517}
3518
3519rule__Atom__Group_3_1__1__Impl
3520 @init {
3521 int stackSize = keepStackSize();
3522 }
3523:
3524(
3525 { before(grammarAccess.getAtomAccess().getArgumentsAssignment_3_1_1()); }
3526 (rule__Atom__ArgumentsAssignment_3_1_1)
3527 { after(grammarAccess.getAtomAccess().getArgumentsAssignment_3_1_1()); }
3528)
3529;
3530finally {
3531 restoreStackSize(stackSize);
3532}
3533
3534
3535rule__Assertion__Group__0
3536 @init {
3537 int stackSize = keepStackSize();
3538 }
3539:
3540 rule__Assertion__Group__0__Impl
3541 rule__Assertion__Group__1
3542;
3543finally {
3544 restoreStackSize(stackSize);
3545}
3546
3547rule__Assertion__Group__0__Impl
3548 @init {
3549 int stackSize = keepStackSize();
3550 }
3551:
3552(
3553 { before(grammarAccess.getAssertionAccess().getAlternatives_0()); }
3554 (rule__Assertion__Alternatives_0)
3555 { after(grammarAccess.getAssertionAccess().getAlternatives_0()); }
3556)
3557;
3558finally {
3559 restoreStackSize(stackSize);
3560}
3561
3562rule__Assertion__Group__1
3563 @init {
3564 int stackSize = keepStackSize();
3565 }
3566:
3567 rule__Assertion__Group__1__Impl
3568;
3569finally {
3570 restoreStackSize(stackSize);
3571}
3572
3573rule__Assertion__Group__1__Impl
3574 @init {
3575 int stackSize = keepStackSize();
3576 }
3577:
3578(
3579 { before(grammarAccess.getAssertionAccess().getFullStopKeyword_1()); }
3580 '.'
3581 { after(grammarAccess.getAssertionAccess().getFullStopKeyword_1()); }
3582)
3583;
3584finally {
3585 restoreStackSize(stackSize);
3586}
3587
3588
3589rule__Assertion__Group_0_0__0
3590 @init {
3591 int stackSize = keepStackSize();
3592 }
3593:
3594 rule__Assertion__Group_0_0__0__Impl
3595 rule__Assertion__Group_0_0__1
3596;
3597finally {
3598 restoreStackSize(stackSize);
3599}
3600
3601rule__Assertion__Group_0_0__0__Impl
3602 @init {
3603 int stackSize = keepStackSize();
3604 }
3605:
3606(
3607 { before(grammarAccess.getAssertionAccess().getRelationAssignment_0_0_0()); }
3608 (rule__Assertion__RelationAssignment_0_0_0)
3609 { after(grammarAccess.getAssertionAccess().getRelationAssignment_0_0_0()); }
3610)
3611;
3612finally {
3613 restoreStackSize(stackSize);
3614}
3615
3616rule__Assertion__Group_0_0__1
3617 @init {
3618 int stackSize = keepStackSize();
3619 }
3620:
3621 rule__Assertion__Group_0_0__1__Impl
3622 rule__Assertion__Group_0_0__2
3623;
3624finally {
3625 restoreStackSize(stackSize);
3626}
3627
3628rule__Assertion__Group_0_0__1__Impl
3629 @init {
3630 int stackSize = keepStackSize();
3631 }
3632:
3633(
3634 { before(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); }
3635 '('
3636 { after(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); }
3637)
3638;
3639finally {
3640 restoreStackSize(stackSize);
3641}
3642
3643rule__Assertion__Group_0_0__2
3644 @init {
3645 int stackSize = keepStackSize();
3646 }
3647:
3648 rule__Assertion__Group_0_0__2__Impl
3649 rule__Assertion__Group_0_0__3
3650;
3651finally {
3652 restoreStackSize(stackSize);
3653}
3654
3655rule__Assertion__Group_0_0__2__Impl
3656 @init {
3657 int stackSize = keepStackSize();
3658 }
3659:
3660(
3661 { before(grammarAccess.getAssertionAccess().getGroup_0_0_2()); }
3662 (rule__Assertion__Group_0_0_2__0)?
3663 { after(grammarAccess.getAssertionAccess().getGroup_0_0_2()); }
3664)
3665;
3666finally {
3667 restoreStackSize(stackSize);
3668}
3669
3670rule__Assertion__Group_0_0__3
3671 @init {
3672 int stackSize = keepStackSize();
3673 }
3674:
3675 rule__Assertion__Group_0_0__3__Impl
3676 rule__Assertion__Group_0_0__4
3677;
3678finally {
3679 restoreStackSize(stackSize);
3680}
3681
3682rule__Assertion__Group_0_0__3__Impl
3683 @init {
3684 int stackSize = keepStackSize();
3685 }
3686:
3687(
3688 { before(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); }
3689 ')'
3690 { after(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); }
3691)
3692;
3693finally {
3694 restoreStackSize(stackSize);
3695}
3696
3697rule__Assertion__Group_0_0__4
3698 @init {
3699 int stackSize = keepStackSize();
3700 }
3701:
3702 rule__Assertion__Group_0_0__4__Impl
3703 rule__Assertion__Group_0_0__5
3704;
3705finally {
3706 restoreStackSize(stackSize);
3707}
3708
3709rule__Assertion__Group_0_0__4__Impl
3710 @init {
3711 int stackSize = keepStackSize();
3712 }
3713:
3714(
3715 { before(grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); }
3716 ':'
3717 { after(grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); }
3718)
3719;
3720finally {
3721 restoreStackSize(stackSize);
3722}
3723
3724rule__Assertion__Group_0_0__5
3725 @init {
3726 int stackSize = keepStackSize();
3727 }
3728:
3729 rule__Assertion__Group_0_0__5__Impl
3730;
3731finally {
3732 restoreStackSize(stackSize);
3733}
3734
3735rule__Assertion__Group_0_0__5__Impl
3736 @init {
3737 int stackSize = keepStackSize();
3738 }
3739:
3740(
3741 { before(grammarAccess.getAssertionAccess().getValueAssignment_0_0_5()); }
3742 (rule__Assertion__ValueAssignment_0_0_5)
3743 { after(grammarAccess.getAssertionAccess().getValueAssignment_0_0_5()); }
3744)
3745;
3746finally {
3747 restoreStackSize(stackSize);
3748}
3749
3750
3751rule__Assertion__Group_0_0_2__0
3752 @init {
3753 int stackSize = keepStackSize();
3754 }
3755:
3756 rule__Assertion__Group_0_0_2__0__Impl
3757 rule__Assertion__Group_0_0_2__1
3758;
3759finally {
3760 restoreStackSize(stackSize);
3761}
3762
3763rule__Assertion__Group_0_0_2__0__Impl
3764 @init {
3765 int stackSize = keepStackSize();
3766 }
3767:
3768(
3769 { before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_0()); }
3770 (rule__Assertion__ArgumentsAssignment_0_0_2_0)
3771 { after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_0()); }
3772)
3773;
3774finally {
3775 restoreStackSize(stackSize);
3776}
3777
3778rule__Assertion__Group_0_0_2__1
3779 @init {
3780 int stackSize = keepStackSize();
3781 }
3782:
3783 rule__Assertion__Group_0_0_2__1__Impl
3784;
3785finally {
3786 restoreStackSize(stackSize);
3787}
3788
3789rule__Assertion__Group_0_0_2__1__Impl
3790 @init {
3791 int stackSize = keepStackSize();
3792 }
3793:
3794(
3795 { before(grammarAccess.getAssertionAccess().getGroup_0_0_2_1()); }
3796 (rule__Assertion__Group_0_0_2_1__0)*
3797 { after(grammarAccess.getAssertionAccess().getGroup_0_0_2_1()); }
3798)
3799;
3800finally {
3801 restoreStackSize(stackSize);
3802}
3803
3804
3805rule__Assertion__Group_0_0_2_1__0
3806 @init {
3807 int stackSize = keepStackSize();
3808 }
3809:
3810 rule__Assertion__Group_0_0_2_1__0__Impl
3811 rule__Assertion__Group_0_0_2_1__1
3812;
3813finally {
3814 restoreStackSize(stackSize);
3815}
3816
3817rule__Assertion__Group_0_0_2_1__0__Impl
3818 @init {
3819 int stackSize = keepStackSize();
3820 }
3821:
3822(
3823 { before(grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); }
3824 ','
3825 { after(grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); }
3826)
3827;
3828finally {
3829 restoreStackSize(stackSize);
3830}
3831
3832rule__Assertion__Group_0_0_2_1__1
3833 @init {
3834 int stackSize = keepStackSize();
3835 }
3836:
3837 rule__Assertion__Group_0_0_2_1__1__Impl
3838;
3839finally {
3840 restoreStackSize(stackSize);
3841}
3842
3843rule__Assertion__Group_0_0_2_1__1__Impl
3844 @init {
3845 int stackSize = keepStackSize();
3846 }
3847:
3848(
3849 { before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_1_1()); }
3850 (rule__Assertion__ArgumentsAssignment_0_0_2_1_1)
3851 { after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_1_1()); }
3852)
3853;
3854finally {
3855 restoreStackSize(stackSize);
3856}
3857
3858
3859rule__Assertion__Group_0_1__0
3860 @init {
3861 int stackSize = keepStackSize();
3862 }
3863:
3864 rule__Assertion__Group_0_1__0__Impl
3865 rule__Assertion__Group_0_1__1
3866;
3867finally {
3868 restoreStackSize(stackSize);
3869}
3870
3871rule__Assertion__Group_0_1__0__Impl
3872 @init {
3873 int stackSize = keepStackSize();
3874 }
3875:
3876(
3877 { before(grammarAccess.getAssertionAccess().getValueAssignment_0_1_0()); }
3878 (rule__Assertion__ValueAssignment_0_1_0)?
3879 { after(grammarAccess.getAssertionAccess().getValueAssignment_0_1_0()); }
3880)
3881;
3882finally {
3883 restoreStackSize(stackSize);
3884}
3885
3886rule__Assertion__Group_0_1__1
3887 @init {
3888 int stackSize = keepStackSize();
3889 }
3890:
3891 rule__Assertion__Group_0_1__1__Impl
3892 rule__Assertion__Group_0_1__2
3893;
3894finally {
3895 restoreStackSize(stackSize);
3896}
3897
3898rule__Assertion__Group_0_1__1__Impl
3899 @init {
3900 int stackSize = keepStackSize();
3901 }
3902:
3903(
3904 { before(grammarAccess.getAssertionAccess().getRelationAssignment_0_1_1()); }
3905 (rule__Assertion__RelationAssignment_0_1_1)
3906 { after(grammarAccess.getAssertionAccess().getRelationAssignment_0_1_1()); }
3907)
3908;
3909finally {
3910 restoreStackSize(stackSize);
3911}
3912
3913rule__Assertion__Group_0_1__2
3914 @init {
3915 int stackSize = keepStackSize();
3916 }
3917:
3918 rule__Assertion__Group_0_1__2__Impl
3919 rule__Assertion__Group_0_1__3
3920;
3921finally {
3922 restoreStackSize(stackSize);
3923}
3924
3925rule__Assertion__Group_0_1__2__Impl
3926 @init {
3927 int stackSize = keepStackSize();
3928 }
3929:
3930(
3931 { before(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); }
3932 '('
3933 { after(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); }
3934)
3935;
3936finally {
3937 restoreStackSize(stackSize);
3938}
3939
3940rule__Assertion__Group_0_1__3
3941 @init {
3942 int stackSize = keepStackSize();
3943 }
3944:
3945 rule__Assertion__Group_0_1__3__Impl
3946 rule__Assertion__Group_0_1__4
3947;
3948finally {
3949 restoreStackSize(stackSize);
3950}
3951
3952rule__Assertion__Group_0_1__3__Impl
3953 @init {
3954 int stackSize = keepStackSize();
3955 }
3956:
3957(
3958 { before(grammarAccess.getAssertionAccess().getGroup_0_1_3()); }
3959 (rule__Assertion__Group_0_1_3__0)?
3960 { after(grammarAccess.getAssertionAccess().getGroup_0_1_3()); }
3961)
3962;
3963finally {
3964 restoreStackSize(stackSize);
3965}
3966
3967rule__Assertion__Group_0_1__4
3968 @init {
3969 int stackSize = keepStackSize();
3970 }
3971:
3972 rule__Assertion__Group_0_1__4__Impl
3973;
3974finally {
3975 restoreStackSize(stackSize);
3976}
3977
3978rule__Assertion__Group_0_1__4__Impl
3979 @init {
3980 int stackSize = keepStackSize();
3981 }
3982:
3983(
3984 { before(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); }
3985 ')'
3986 { after(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); }
3987)
3988;
3989finally {
3990 restoreStackSize(stackSize);
3991}
3992
3993
3994rule__Assertion__Group_0_1_3__0
3995 @init {
3996 int stackSize = keepStackSize();
3997 }
3998:
3999 rule__Assertion__Group_0_1_3__0__Impl
4000 rule__Assertion__Group_0_1_3__1
4001;
4002finally {
4003 restoreStackSize(stackSize);
4004}
4005
4006rule__Assertion__Group_0_1_3__0__Impl
4007 @init {
4008 int stackSize = keepStackSize();
4009 }
4010:
4011(
4012 { before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_0()); }
4013 (rule__Assertion__ArgumentsAssignment_0_1_3_0)
4014 { after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_0()); }
4015)
4016;
4017finally {
4018 restoreStackSize(stackSize);
4019}
4020
4021rule__Assertion__Group_0_1_3__1
4022 @init {
4023 int stackSize = keepStackSize();
4024 }
4025:
4026 rule__Assertion__Group_0_1_3__1__Impl
4027;
4028finally {
4029 restoreStackSize(stackSize);
4030}
4031
4032rule__Assertion__Group_0_1_3__1__Impl
4033 @init {
4034 int stackSize = keepStackSize();
4035 }
4036:
4037(
4038 { before(grammarAccess.getAssertionAccess().getGroup_0_1_3_1()); }
4039 (rule__Assertion__Group_0_1_3_1__0)*
4040 { after(grammarAccess.getAssertionAccess().getGroup_0_1_3_1()); }
4041)
4042;
4043finally {
4044 restoreStackSize(stackSize);
4045}
4046
4047
4048rule__Assertion__Group_0_1_3_1__0
4049 @init {
4050 int stackSize = keepStackSize();
4051 }
4052:
4053 rule__Assertion__Group_0_1_3_1__0__Impl
4054 rule__Assertion__Group_0_1_3_1__1
4055;
4056finally {
4057 restoreStackSize(stackSize);
4058}
4059
4060rule__Assertion__Group_0_1_3_1__0__Impl
4061 @init {
4062 int stackSize = keepStackSize();
4063 }
4064:
4065(
4066 { before(grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); }
4067 ','
4068 { after(grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); }
4069)
4070;
4071finally {
4072 restoreStackSize(stackSize);
4073}
4074
4075rule__Assertion__Group_0_1_3_1__1
4076 @init {
4077 int stackSize = keepStackSize();
4078 }
4079:
4080 rule__Assertion__Group_0_1_3_1__1__Impl
4081;
4082finally {
4083 restoreStackSize(stackSize);
4084}
4085
4086rule__Assertion__Group_0_1_3_1__1__Impl
4087 @init {
4088 int stackSize = keepStackSize();
4089 }
4090:
4091(
4092 { before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_1_1()); }
4093 (rule__Assertion__ArgumentsAssignment_0_1_3_1_1)
4094 { after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_1_1()); }
4095)
4096;
4097finally {
4098 restoreStackSize(stackSize);
4099}
4100
4101
4102rule__NodeValueAssertion__Group__0
4103 @init {
4104 int stackSize = keepStackSize();
4105 }
4106:
4107 rule__NodeValueAssertion__Group__0__Impl
4108 rule__NodeValueAssertion__Group__1
4109;
4110finally {
4111 restoreStackSize(stackSize);
4112}
4113
4114rule__NodeValueAssertion__Group__0__Impl
4115 @init {
4116 int stackSize = keepStackSize();
4117 }
4118:
4119(
4120 { before(grammarAccess.getNodeValueAssertionAccess().getNodeAssignment_0()); }
4121 (rule__NodeValueAssertion__NodeAssignment_0)
4122 { after(grammarAccess.getNodeValueAssertionAccess().getNodeAssignment_0()); }
4123)
4124;
4125finally {
4126 restoreStackSize(stackSize);
4127}
4128
4129rule__NodeValueAssertion__Group__1
4130 @init {
4131 int stackSize = keepStackSize();
4132 }
4133:
4134 rule__NodeValueAssertion__Group__1__Impl
4135 rule__NodeValueAssertion__Group__2
4136;
4137finally {
4138 restoreStackSize(stackSize);
4139}
4140
4141rule__NodeValueAssertion__Group__1__Impl
4142 @init {
4143 int stackSize = keepStackSize();
4144 }
4145:
4146(
4147 { before(grammarAccess.getNodeValueAssertionAccess().getColonKeyword_1()); }
4148 ':'
4149 { after(grammarAccess.getNodeValueAssertionAccess().getColonKeyword_1()); }
4150)
4151;
4152finally {
4153 restoreStackSize(stackSize);
4154}
4155
4156rule__NodeValueAssertion__Group__2
4157 @init {
4158 int stackSize = keepStackSize();
4159 }
4160:
4161 rule__NodeValueAssertion__Group__2__Impl
4162 rule__NodeValueAssertion__Group__3
4163;
4164finally {
4165 restoreStackSize(stackSize);
4166}
4167
4168rule__NodeValueAssertion__Group__2__Impl
4169 @init {
4170 int stackSize = keepStackSize();
4171 }
4172:
4173(
4174 { before(grammarAccess.getNodeValueAssertionAccess().getValueAssignment_2()); }
4175 (rule__NodeValueAssertion__ValueAssignment_2)
4176 { after(grammarAccess.getNodeValueAssertionAccess().getValueAssignment_2()); }
4177)
4178;
4179finally {
4180 restoreStackSize(stackSize);
4181}
4182
4183rule__NodeValueAssertion__Group__3
4184 @init {
4185 int stackSize = keepStackSize();
4186 }
4187:
4188 rule__NodeValueAssertion__Group__3__Impl
4189;
4190finally {
4191 restoreStackSize(stackSize);
4192}
4193
4194rule__NodeValueAssertion__Group__3__Impl
4195 @init {
4196 int stackSize = keepStackSize();
4197 }
4198:
4199(
4200 { before(grammarAccess.getNodeValueAssertionAccess().getFullStopKeyword_3()); }
4201 '.'
4202 { after(grammarAccess.getNodeValueAssertionAccess().getFullStopKeyword_3()); }
4203)
4204;
4205finally {
4206 restoreStackSize(stackSize);
4207}
4208
4209
4210rule__ScopeDeclaration__Group__0
4211 @init {
4212 int stackSize = keepStackSize();
4213 }
4214:
4215 rule__ScopeDeclaration__Group__0__Impl
4216 rule__ScopeDeclaration__Group__1
4217;
4218finally {
4219 restoreStackSize(stackSize);
4220}
4221
4222rule__ScopeDeclaration__Group__0__Impl
4223 @init {
4224 int stackSize = keepStackSize();
4225 }
4226:
4227(
4228 { before(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); }
4229 'scope'
4230 { after(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); }
4231)
4232;
4233finally {
4234 restoreStackSize(stackSize);
4235}
4236
4237rule__ScopeDeclaration__Group__1
4238 @init {
4239 int stackSize = keepStackSize();
4240 }
4241:
4242 rule__ScopeDeclaration__Group__1__Impl
4243 rule__ScopeDeclaration__Group__2
4244;
4245finally {
4246 restoreStackSize(stackSize);
4247}
4248
4249rule__ScopeDeclaration__Group__1__Impl
4250 @init {
4251 int stackSize = keepStackSize();
4252 }
4253:
4254(
4255 { before(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_1()); }
4256 (rule__ScopeDeclaration__TypeScopesAssignment_1)
4257 { after(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_1()); }
4258)
4259;
4260finally {
4261 restoreStackSize(stackSize);
4262}
4263
4264rule__ScopeDeclaration__Group__2
4265 @init {
4266 int stackSize = keepStackSize();
4267 }
4268:
4269 rule__ScopeDeclaration__Group__2__Impl
4270 rule__ScopeDeclaration__Group__3
4271;
4272finally {
4273 restoreStackSize(stackSize);
4274}
4275
4276rule__ScopeDeclaration__Group__2__Impl
4277 @init {
4278 int stackSize = keepStackSize();
4279 }
4280:
4281(
4282 { before(grammarAccess.getScopeDeclarationAccess().getGroup_2()); }
4283 (rule__ScopeDeclaration__Group_2__0)*
4284 { after(grammarAccess.getScopeDeclarationAccess().getGroup_2()); }
4285)
4286;
4287finally {
4288 restoreStackSize(stackSize);
4289}
4290
4291rule__ScopeDeclaration__Group__3
4292 @init {
4293 int stackSize = keepStackSize();
4294 }
4295:
4296 rule__ScopeDeclaration__Group__3__Impl
4297;
4298finally {
4299 restoreStackSize(stackSize);
4300}
4301
4302rule__ScopeDeclaration__Group__3__Impl
4303 @init {
4304 int stackSize = keepStackSize();
4305 }
4306:
4307(
4308 { before(grammarAccess.getScopeDeclarationAccess().getFullStopKeyword_3()); }
4309 '.'
4310 { after(grammarAccess.getScopeDeclarationAccess().getFullStopKeyword_3()); }
4311)
4312;
4313finally {
4314 restoreStackSize(stackSize);
4315}
4316
4317
4318rule__ScopeDeclaration__Group_2__0
4319 @init {
4320 int stackSize = keepStackSize();
4321 }
4322:
4323 rule__ScopeDeclaration__Group_2__0__Impl
4324 rule__ScopeDeclaration__Group_2__1
4325;
4326finally {
4327 restoreStackSize(stackSize);
4328}
4329
4330rule__ScopeDeclaration__Group_2__0__Impl
4331 @init {
4332 int stackSize = keepStackSize();
4333 }
4334:
4335(
4336 { before(grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); }
4337 ','
4338 { after(grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); }
4339)
4340;
4341finally {
4342 restoreStackSize(stackSize);
4343}
4344
4345rule__ScopeDeclaration__Group_2__1
4346 @init {
4347 int stackSize = keepStackSize();
4348 }
4349:
4350 rule__ScopeDeclaration__Group_2__1__Impl
4351;
4352finally {
4353 restoreStackSize(stackSize);
4354}
4355
4356rule__ScopeDeclaration__Group_2__1__Impl
4357 @init {
4358 int stackSize = keepStackSize();
4359 }
4360:
4361(
4362 { before(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_2_1()); }
4363 (rule__ScopeDeclaration__TypeScopesAssignment_2_1)
4364 { after(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_2_1()); }
4365)
4366;
4367finally {
4368 restoreStackSize(stackSize);
4369}
4370
4371
4372rule__TypeScope__Group__0
4373 @init {
4374 int stackSize = keepStackSize();
4375 }
4376:
4377 rule__TypeScope__Group__0__Impl
4378 rule__TypeScope__Group__1
4379;
4380finally {
4381 restoreStackSize(stackSize);
4382}
4383
4384rule__TypeScope__Group__0__Impl
4385 @init {
4386 int stackSize = keepStackSize();
4387 }
4388:
4389(
4390 { before(grammarAccess.getTypeScopeAccess().getTargetTypeAssignment_0()); }
4391 (rule__TypeScope__TargetTypeAssignment_0)
4392 { after(grammarAccess.getTypeScopeAccess().getTargetTypeAssignment_0()); }
4393)
4394;
4395finally {
4396 restoreStackSize(stackSize);
4397}
4398
4399rule__TypeScope__Group__1
4400 @init {
4401 int stackSize = keepStackSize();
4402 }
4403:
4404 rule__TypeScope__Group__1__Impl
4405 rule__TypeScope__Group__2
4406;
4407finally {
4408 restoreStackSize(stackSize);
4409}
4410
4411rule__TypeScope__Group__1__Impl
4412 @init {
4413 int stackSize = keepStackSize();
4414 }
4415:
4416(
4417 { before(grammarAccess.getTypeScopeAccess().getAlternatives_1()); }
4418 (rule__TypeScope__Alternatives_1)
4419 { after(grammarAccess.getTypeScopeAccess().getAlternatives_1()); }
4420)
4421;
4422finally {
4423 restoreStackSize(stackSize);
4424}
4425
4426rule__TypeScope__Group__2
4427 @init {
4428 int stackSize = keepStackSize();
4429 }
4430:
4431 rule__TypeScope__Group__2__Impl
4432;
4433finally {
4434 restoreStackSize(stackSize);
4435}
4436
4437rule__TypeScope__Group__2__Impl
4438 @init {
4439 int stackSize = keepStackSize();
4440 }
4441:
4442(
4443 { before(grammarAccess.getTypeScopeAccess().getMultiplicityAssignment_2()); }
4444 (rule__TypeScope__MultiplicityAssignment_2)
4445 { after(grammarAccess.getTypeScopeAccess().getMultiplicityAssignment_2()); }
4446)
4447;
4448finally {
4449 restoreStackSize(stackSize);
4450}
4451
4452
4453rule__RangeMultiplicity__Group__0
4454 @init {
4455 int stackSize = keepStackSize();
4456 }
4457:
4458 rule__RangeMultiplicity__Group__0__Impl
4459 rule__RangeMultiplicity__Group__1
4460;
4461finally {
4462 restoreStackSize(stackSize);
4463}
4464
4465rule__RangeMultiplicity__Group__0__Impl
4466 @init {
4467 int stackSize = keepStackSize();
4468 }
4469:
4470(
4471 { before(grammarAccess.getRangeMultiplicityAccess().getLowerBoundAssignment_0()); }
4472 (rule__RangeMultiplicity__LowerBoundAssignment_0)
4473 { after(grammarAccess.getRangeMultiplicityAccess().getLowerBoundAssignment_0()); }
4474)
4475;
4476finally {
4477 restoreStackSize(stackSize);
4478}
4479
4480rule__RangeMultiplicity__Group__1
4481 @init {
4482 int stackSize = keepStackSize();
4483 }
4484:
4485 rule__RangeMultiplicity__Group__1__Impl
4486 rule__RangeMultiplicity__Group__2
4487;
4488finally {
4489 restoreStackSize(stackSize);
4490}
4491
4492rule__RangeMultiplicity__Group__1__Impl
4493 @init {
4494 int stackSize = keepStackSize();
4495 }
4496:
4497(
4498 { before(grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); }
4499 '..'
4500 { after(grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); }
4501)
4502;
4503finally {
4504 restoreStackSize(stackSize);
4505}
4506
4507rule__RangeMultiplicity__Group__2
4508 @init {
4509 int stackSize = keepStackSize();
4510 }
4511:
4512 rule__RangeMultiplicity__Group__2__Impl
4513;
4514finally {
4515 restoreStackSize(stackSize);
4516}
4517
4518rule__RangeMultiplicity__Group__2__Impl
4519 @init {
4520 int stackSize = keepStackSize();
4521 }
4522:
4523(
4524 { before(grammarAccess.getRangeMultiplicityAccess().getUpperBoundAssignment_2()); }
4525 (rule__RangeMultiplicity__UpperBoundAssignment_2)
4526 { after(grammarAccess.getRangeMultiplicityAccess().getUpperBoundAssignment_2()); }
4527)
4528;
4529finally {
4530 restoreStackSize(stackSize);
4531}
4532
4533
4534rule__QualifiedName__Group_1__0
4535 @init {
4536 int stackSize = keepStackSize();
4537 }
4538:
4539 rule__QualifiedName__Group_1__0__Impl
4540 rule__QualifiedName__Group_1__1
4541;
4542finally {
4543 restoreStackSize(stackSize);
4544}
4545
4546rule__QualifiedName__Group_1__0__Impl
4547 @init {
4548 int stackSize = keepStackSize();
4549 }
4550:
4551(
4552 { before(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); }
4553 ruleIdentifier
4554 { after(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); }
4555)
4556;
4557finally {
4558 restoreStackSize(stackSize);
4559}
4560
4561rule__QualifiedName__Group_1__1
4562 @init {
4563 int stackSize = keepStackSize();
4564 }
4565:
4566 rule__QualifiedName__Group_1__1__Impl
4567;
4568finally {
4569 restoreStackSize(stackSize);
4570}
4571
4572rule__QualifiedName__Group_1__1__Impl
4573 @init {
4574 int stackSize = keepStackSize();
4575 }
4576:
4577(
4578 { before(grammarAccess.getQualifiedNameAccess().getGroup_1_1()); }
4579 (rule__QualifiedName__Group_1_1__0)*
4580 { after(grammarAccess.getQualifiedNameAccess().getGroup_1_1()); }
4581)
4582;
4583finally {
4584 restoreStackSize(stackSize);
4585}
4586
4587
4588rule__QualifiedName__Group_1_1__0
4589 @init {
4590 int stackSize = keepStackSize();
4591 }
4592:
4593 rule__QualifiedName__Group_1_1__0__Impl
4594 rule__QualifiedName__Group_1_1__1
4595;
4596finally {
4597 restoreStackSize(stackSize);
4598}
4599
4600rule__QualifiedName__Group_1_1__0__Impl
4601 @init {
4602 int stackSize = keepStackSize();
4603 }
4604:
4605(
4606 { before(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_1_0()); }
4607 '::'
4608 { after(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_1_0()); }
4609)
4610;
4611finally {
4612 restoreStackSize(stackSize);
4613}
4614
4615rule__QualifiedName__Group_1_1__1
4616 @init {
4617 int stackSize = keepStackSize();
4618 }
4619:
4620 rule__QualifiedName__Group_1_1__1__Impl
4621;
4622finally {
4623 restoreStackSize(stackSize);
4624}
4625
4626rule__QualifiedName__Group_1_1__1__Impl
4627 @init {
4628 int stackSize = keepStackSize();
4629 }
4630:
4631(
4632 { before(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); }
4633 ruleIdentifier
4634 { after(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); }
4635)
4636;
4637finally {
4638 restoreStackSize(stackSize);
4639}
4640
4641
4642rule__Integer__Group__0
4643 @init {
4644 int stackSize = keepStackSize();
4645 }
4646:
4647 rule__Integer__Group__0__Impl
4648 rule__Integer__Group__1
4649;
4650finally {
4651 restoreStackSize(stackSize);
4652}
4653
4654rule__Integer__Group__0__Impl
4655 @init {
4656 int stackSize = keepStackSize();
4657 }
4658:
4659(
4660 { before(grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0()); }
4661 ('-')?
4662 { after(grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0()); }
4663)
4664;
4665finally {
4666 restoreStackSize(stackSize);
4667}
4668
4669rule__Integer__Group__1
4670 @init {
4671 int stackSize = keepStackSize();
4672 }
4673:
4674 rule__Integer__Group__1__Impl
4675;
4676finally {
4677 restoreStackSize(stackSize);
4678}
4679
4680rule__Integer__Group__1__Impl
4681 @init {
4682 int stackSize = keepStackSize();
4683 }
4684:
4685(
4686 { before(grammarAccess.getIntegerAccess().getINTTerminalRuleCall_1()); }
4687 RULE_INT
4688 { after(grammarAccess.getIntegerAccess().getINTTerminalRuleCall_1()); }
4689)
4690;
4691finally {
4692 restoreStackSize(stackSize);
4693}
4694
4695
4696rule__Real__Group__0
4697 @init {
4698 int stackSize = keepStackSize();
4699 }
4700:
4701 rule__Real__Group__0__Impl
4702 rule__Real__Group__1
4703;
4704finally {
4705 restoreStackSize(stackSize);
4706}
4707
4708rule__Real__Group__0__Impl
4709 @init {
4710 int stackSize = keepStackSize();
4711 }
4712:
4713(
4714 { before(grammarAccess.getRealAccess().getHyphenMinusKeyword_0()); }
4715 ('-')?
4716 { after(grammarAccess.getRealAccess().getHyphenMinusKeyword_0()); }
4717)
4718;
4719finally {
4720 restoreStackSize(stackSize);
4721}
4722
4723rule__Real__Group__1
4724 @init {
4725 int stackSize = keepStackSize();
4726 }
4727:
4728 rule__Real__Group__1__Impl
4729;
4730finally {
4731 restoreStackSize(stackSize);
4732}
4733
4734rule__Real__Group__1__Impl
4735 @init {
4736 int stackSize = keepStackSize();
4737 }
4738:
4739(
4740 { before(grammarAccess.getRealAccess().getAlternatives_1()); }
4741 (rule__Real__Alternatives_1)
4742 { after(grammarAccess.getRealAccess().getAlternatives_1()); }
4743)
4744;
4745finally {
4746 restoreStackSize(stackSize);
4747}
4748
4749
4750rule__Real__Group_1_1__0
4751 @init {
4752 int stackSize = keepStackSize();
4753 }
4754:
4755 rule__Real__Group_1_1__0__Impl
4756 rule__Real__Group_1_1__1
4757;
4758finally {
4759 restoreStackSize(stackSize);
4760}
4761
4762rule__Real__Group_1_1__0__Impl
4763 @init {
4764 int stackSize = keepStackSize();
4765 }
4766:
4767(
4768 { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1_0()); }
4769 RULE_INT
4770 { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1_0()); }
4771)
4772;
4773finally {
4774 restoreStackSize(stackSize);
4775}
4776
4777rule__Real__Group_1_1__1
4778 @init {
4779 int stackSize = keepStackSize();
4780 }
4781:
4782 rule__Real__Group_1_1__1__Impl
4783 rule__Real__Group_1_1__2
4784;
4785finally {
4786 restoreStackSize(stackSize);
4787}
4788
4789rule__Real__Group_1_1__1__Impl
4790 @init {
4791 int stackSize = keepStackSize();
4792 }
4793:
4794(
4795 { before(grammarAccess.getRealAccess().getFullStopKeyword_1_1_1()); }
4796 '.'
4797 { after(grammarAccess.getRealAccess().getFullStopKeyword_1_1_1()); }
4798)
4799;
4800finally {
4801 restoreStackSize(stackSize);
4802}
4803
4804rule__Real__Group_1_1__2
4805 @init {
4806 int stackSize = keepStackSize();
4807 }
4808:
4809 rule__Real__Group_1_1__2__Impl
4810;
4811finally {
4812 restoreStackSize(stackSize);
4813}
4814
4815rule__Real__Group_1_1__2__Impl
4816 @init {
4817 int stackSize = keepStackSize();
4818 }
4819:
4820(
4821 { before(grammarAccess.getRealAccess().getAlternatives_1_1_2()); }
4822 (rule__Real__Alternatives_1_1_2)
4823 { after(grammarAccess.getRealAccess().getAlternatives_1_1_2()); }
4824)
4825;
4826finally {
4827 restoreStackSize(stackSize);
4828}
4829
4830
4831rule__Problem__NameAssignment_0_1
4832 @init {
4833 int stackSize = keepStackSize();
4834 }
4835:
4836 (
4837 { before(grammarAccess.getProblemAccess().getNameIdentifierParserRuleCall_0_1_0()); }
4838 ruleIdentifier
4839 { after(grammarAccess.getProblemAccess().getNameIdentifierParserRuleCall_0_1_0()); }
4840 )
4841;
4842finally {
4843 restoreStackSize(stackSize);
4844}
4845
4846rule__Problem__StatementsAssignment_1
4847 @init {
4848 int stackSize = keepStackSize();
4849 }
4850:
4851 (
4852 { before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_1_0()); }
4853 ruleStatement
4854 { after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_1_0()); }
4855 )
4856;
4857finally {
4858 restoreStackSize(stackSize);
4859}
4860
4861rule__ClassDeclaration__AbstractAssignment_0
4862 @init {
4863 int stackSize = keepStackSize();
4864 }
4865:
4866 (
4867 { before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); }
4868 (
4869 { before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); }
4870 'abstract'
4871 { after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); }
4872 )
4873 { after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); }
4874 )
4875;
4876finally {
4877 restoreStackSize(stackSize);
4878}
4879
4880rule__ClassDeclaration__NameAssignment_2
4881 @init {
4882 int stackSize = keepStackSize();
4883 }
4884:
4885 (
4886 { before(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); }
4887 ruleIdentifier
4888 { after(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); }
4889 )
4890;
4891finally {
4892 restoreStackSize(stackSize);
4893}
4894
4895rule__ClassDeclaration__SuperTypesAssignment_3_1
4896 @init {
4897 int stackSize = keepStackSize();
4898 }
4899:
4900 (
4901 { before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_1_0()); }
4902 (
4903 { before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_1_0_1()); }
4904 ruleQualifiedName
4905 { after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_1_0_1()); }
4906 )
4907 { after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_1_0()); }
4908 )
4909;
4910finally {
4911 restoreStackSize(stackSize);
4912}
4913
4914rule__ClassDeclaration__SuperTypesAssignment_3_2_1
4915 @init {
4916 int stackSize = keepStackSize();
4917 }
4918:
4919 (
4920 { before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_2_1_0()); }
4921 (
4922 { before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_2_1_0_1()); }
4923 ruleQualifiedName
4924 { after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_2_1_0_1()); }
4925 )
4926 { after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_2_1_0()); }
4927 )
4928;
4929finally {
4930 restoreStackSize(stackSize);
4931}
4932
4933rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0
4934 @init {
4935 int stackSize = keepStackSize();
4936 }
4937:
4938 (
4939 { before(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); }
4940 ruleReferenceDeclaration
4941 { after(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); }
4942 )
4943;
4944finally {
4945 restoreStackSize(stackSize);
4946}
4947
4948rule__EnumDeclaration__NameAssignment_1
4949 @init {
4950 int stackSize = keepStackSize();
4951 }
4952:
4953 (
4954 { before(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); }
4955 ruleIdentifier
4956 { after(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); }
4957 )
4958;
4959finally {
4960 restoreStackSize(stackSize);
4961}
4962
4963rule__EnumDeclaration__LiteralsAssignment_2_0_1_0
4964 @init {
4965 int stackSize = keepStackSize();
4966 }
4967:
4968 (
4969 { before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); }
4970 ruleEnumLiteral
4971 { after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); }
4972 )
4973;
4974finally {
4975 restoreStackSize(stackSize);
4976}
4977
4978rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1
4979 @init {
4980 int stackSize = keepStackSize();
4981 }
4982:
4983 (
4984 { before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); }
4985 ruleEnumLiteral
4986 { after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); }
4987 )
4988;
4989finally {
4990 restoreStackSize(stackSize);
4991}
4992
4993rule__EnumLiteral__NameAssignment
4994 @init {
4995 int stackSize = keepStackSize();
4996 }
4997:
4998 (
4999 { before(grammarAccess.getEnumLiteralAccess().getNameIdentifierParserRuleCall_0()); }
5000 ruleIdentifier
5001 { after(grammarAccess.getEnumLiteralAccess().getNameIdentifierParserRuleCall_0()); }
5002 )
5003;
5004finally {
5005 restoreStackSize(stackSize);
5006}
5007
5008rule__ReferenceDeclaration__ContainmentAssignment_0_0
5009 @init {
5010 int stackSize = keepStackSize();
5011 }
5012:
5013 (
5014 { before(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); }
5015 (
5016 { before(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); }
5017 'contains'
5018 { after(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); }
5019 )
5020 { after(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); }
5021 )
5022;
5023finally {
5024 restoreStackSize(stackSize);
5025}
5026
5027rule__ReferenceDeclaration__ReferenceTypeAssignment_1
5028 @init {
5029 int stackSize = keepStackSize();
5030 }
5031:
5032 (
5033 { before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationCrossReference_1_0()); }
5034 (
5035 { before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationQualifiedNameParserRuleCall_1_0_1()); }
5036 ruleQualifiedName
5037 { after(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationQualifiedNameParserRuleCall_1_0_1()); }
5038 )
5039 { after(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationCrossReference_1_0()); }
5040 )
5041;
5042finally {
5043 restoreStackSize(stackSize);
5044}
5045
5046rule__ReferenceDeclaration__MultiplicityAssignment_2_1
5047 @init {
5048 int stackSize = keepStackSize();
5049 }
5050:
5051 (
5052 { before(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); }
5053 ruleMultiplicity
5054 { after(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); }
5055 )
5056;
5057finally {
5058 restoreStackSize(stackSize);
5059}
5060
5061rule__ReferenceDeclaration__NameAssignment_3
5062 @init {
5063 int stackSize = keepStackSize();
5064 }
5065:
5066 (
5067 { before(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); }
5068 ruleIdentifier
5069 { after(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); }
5070 )
5071;
5072finally {
5073 restoreStackSize(stackSize);
5074}
5075
5076rule__ReferenceDeclaration__OppositeAssignment_4_1
5077 @init {
5078 int stackSize = keepStackSize();
5079 }
5080:
5081 (
5082 { before(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationCrossReference_4_1_0()); }
5083 (
5084 { before(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationQualifiedNameParserRuleCall_4_1_0_1()); }
5085 ruleQualifiedName
5086 { after(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationQualifiedNameParserRuleCall_4_1_0_1()); }
5087 )
5088 { after(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationCrossReference_4_1_0()); }
5089 )
5090;
5091finally {
5092 restoreStackSize(stackSize);
5093}
5094
5095rule__PredicateDefinition__ErrorAssignment_0_0_0
5096 @init {
5097 int stackSize = keepStackSize();
5098 }
5099:
5100 (
5101 { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); }
5102 (
5103 { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); }
5104 'error'
5105 { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); }
5106 )
5107 { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); }
5108 )
5109;
5110finally {
5111 restoreStackSize(stackSize);
5112}
5113
5114rule__PredicateDefinition__NameAssignment_1
5115 @init {
5116 int stackSize = keepStackSize();
5117 }
5118:
5119 (
5120 { before(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); }
5121 ruleIdentifier
5122 { after(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); }
5123 )
5124;
5125finally {
5126 restoreStackSize(stackSize);
5127}
5128
5129rule__PredicateDefinition__ParametersAssignment_3_0
5130 @init {
5131 int stackSize = keepStackSize();
5132 }
5133:
5134 (
5135 { before(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); }
5136 ruleParameter
5137 { after(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); }
5138 )
5139;
5140finally {
5141 restoreStackSize(stackSize);
5142}
5143
5144rule__PredicateDefinition__ParametersAssignment_3_1_1
5145 @init {
5146 int stackSize = keepStackSize();
5147 }
5148:
5149 (
5150 { before(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); }
5151 ruleParameter
5152 { after(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); }
5153 )
5154;
5155finally {
5156 restoreStackSize(stackSize);
5157}
5158
5159rule__PredicateDefinition__BodiesAssignment_5_1
5160 @init {
5161 int stackSize = keepStackSize();
5162 }
5163:
5164 (
5165 { before(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); }
5166 ruleConjunction
5167 { after(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); }
5168 )
5169;
5170finally {
5171 restoreStackSize(stackSize);
5172}
5173
5174rule__PredicateDefinition__BodiesAssignment_5_2_1
5175 @init {
5176 int stackSize = keepStackSize();
5177 }
5178:
5179 (
5180 { before(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); }
5181 ruleConjunction
5182 { after(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); }
5183 )
5184;
5185finally {
5186 restoreStackSize(stackSize);
5187}
5188
5189rule__Parameter__ParameterTypeAssignment_0
5190 @init {
5191 int stackSize = keepStackSize();
5192 }
5193:
5194 (
5195 { before(grammarAccess.getParameterAccess().getParameterTypeRelationCrossReference_0_0()); }
5196 (
5197 { before(grammarAccess.getParameterAccess().getParameterTypeRelationQualifiedNameParserRuleCall_0_0_1()); }
5198 ruleQualifiedName
5199 { after(grammarAccess.getParameterAccess().getParameterTypeRelationQualifiedNameParserRuleCall_0_0_1()); }
5200 )
5201 { after(grammarAccess.getParameterAccess().getParameterTypeRelationCrossReference_0_0()); }
5202 )
5203;
5204finally {
5205 restoreStackSize(stackSize);
5206}
5207
5208rule__Parameter__NameAssignment_1
5209 @init {
5210 int stackSize = keepStackSize();
5211 }
5212:
5213 (
5214 { before(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); }
5215 ruleIdentifier
5216 { after(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); }
5217 )
5218;
5219finally {
5220 restoreStackSize(stackSize);
5221}
5222
5223rule__Conjunction__LiteralsAssignment_0
5224 @init {
5225 int stackSize = keepStackSize();
5226 }
5227:
5228 (
5229 { before(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); }
5230 ruleLiteral
5231 { after(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); }
5232 )
5233;
5234finally {
5235 restoreStackSize(stackSize);
5236}
5237
5238rule__Conjunction__LiteralsAssignment_1_1
5239 @init {
5240 int stackSize = keepStackSize();
5241 }
5242:
5243 (
5244 { before(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); }
5245 ruleLiteral
5246 { after(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); }
5247 )
5248;
5249finally {
5250 restoreStackSize(stackSize);
5251}
5252
5253rule__NegativeLiteral__AtomAssignment_1
5254 @init {
5255 int stackSize = keepStackSize();
5256 }
5257:
5258 (
5259 { before(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); }
5260 ruleAtom
5261 { after(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); }
5262 )
5263;
5264finally {
5265 restoreStackSize(stackSize);
5266}
5267
5268rule__Atom__RelationAssignment_0
5269 @init {
5270 int stackSize = keepStackSize();
5271 }
5272:
5273 (
5274 { before(grammarAccess.getAtomAccess().getRelationRelationCrossReference_0_0()); }
5275 (
5276 { before(grammarAccess.getAtomAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_1()); }
5277 ruleQualifiedName
5278 { after(grammarAccess.getAtomAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_1()); }
5279 )
5280 { after(grammarAccess.getAtomAccess().getRelationRelationCrossReference_0_0()); }
5281 )
5282;
5283finally {
5284 restoreStackSize(stackSize);
5285}
5286
5287rule__Atom__TransitiveClosureAssignment_1
5288 @init {
5289 int stackSize = keepStackSize();
5290 }
5291:
5292 (
5293 { before(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); }
5294 (
5295 { before(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); }
5296 '+'
5297 { after(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); }
5298 )
5299 { after(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); }
5300 )
5301;
5302finally {
5303 restoreStackSize(stackSize);
5304}
5305
5306rule__Atom__ArgumentsAssignment_3_0
5307 @init {
5308 int stackSize = keepStackSize();
5309 }
5310:
5311 (
5312 { before(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); }
5313 ruleArgument
5314 { after(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); }
5315 )
5316;
5317finally {
5318 restoreStackSize(stackSize);
5319}
5320
5321rule__Atom__ArgumentsAssignment_3_1_1
5322 @init {
5323 int stackSize = keepStackSize();
5324 }
5325:
5326 (
5327 { before(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); }
5328 ruleArgument
5329 { after(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); }
5330 )
5331;
5332finally {
5333 restoreStackSize(stackSize);
5334}
5335
5336rule__VariableOrNodeArgument__VariableOrNodeAssignment
5337 @init {
5338 int stackSize = keepStackSize();
5339 }
5340:
5341 (
5342 { before(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); }
5343 (
5344 { before(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); }
5345 ruleQualifiedName
5346 { after(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); }
5347 )
5348 { after(grammarAccess.getVariableOrNodeArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); }
5349 )
5350;
5351finally {
5352 restoreStackSize(stackSize);
5353}
5354
5355rule__ConstantArgument__ConstantAssignment
5356 @init {
5357 int stackSize = keepStackSize();
5358 }
5359:
5360 (
5361 { before(grammarAccess.getConstantArgumentAccess().getConstantConstantParserRuleCall_0()); }
5362 ruleConstant
5363 { after(grammarAccess.getConstantArgumentAccess().getConstantConstantParserRuleCall_0()); }
5364 )
5365;
5366finally {
5367 restoreStackSize(stackSize);
5368}
5369
5370rule__Assertion__RelationAssignment_0_0_0
5371 @init {
5372 int stackSize = keepStackSize();
5373 }
5374:
5375 (
5376 { before(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_0_0_0()); }
5377 (
5378 { before(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_0_0_1()); }
5379 ruleQualifiedName
5380 { after(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_0_0_1()); }
5381 )
5382 { after(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_0_0_0()); }
5383 )
5384;
5385finally {
5386 restoreStackSize(stackSize);
5387}
5388
5389rule__Assertion__ArgumentsAssignment_0_0_2_0
5390 @init {
5391 int stackSize = keepStackSize();
5392 }
5393:
5394 (
5395 { before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_0_0()); }
5396 ruleAssertionArgument
5397 { after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_0_0()); }
5398 )
5399;
5400finally {
5401 restoreStackSize(stackSize);
5402}
5403
5404rule__Assertion__ArgumentsAssignment_0_0_2_1_1
5405 @init {
5406 int stackSize = keepStackSize();
5407 }
5408:
5409 (
5410 { before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_1_1_0()); }
5411 ruleAssertionArgument
5412 { after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_0_2_1_1_0()); }
5413 )
5414;
5415finally {
5416 restoreStackSize(stackSize);
5417}
5418
5419rule__Assertion__ValueAssignment_0_0_5
5420 @init {
5421 int stackSize = keepStackSize();
5422 }
5423:
5424 (
5425 { before(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); }
5426 ruleLogicValue
5427 { after(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); }
5428 )
5429;
5430finally {
5431 restoreStackSize(stackSize);
5432}
5433
5434rule__Assertion__ValueAssignment_0_1_0
5435 @init {
5436 int stackSize = keepStackSize();
5437 }
5438:
5439 (
5440 { before(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); }
5441 ruleShortLogicValue
5442 { after(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); }
5443 )
5444;
5445finally {
5446 restoreStackSize(stackSize);
5447}
5448
5449rule__Assertion__RelationAssignment_0_1_1
5450 @init {
5451 int stackSize = keepStackSize();
5452 }
5453:
5454 (
5455 { before(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_1_1_0()); }
5456 (
5457 { before(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_1_1_0_1()); }
5458 ruleQualifiedName
5459 { after(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_1_1_0_1()); }
5460 )
5461 { after(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_1_1_0()); }
5462 )
5463;
5464finally {
5465 restoreStackSize(stackSize);
5466}
5467
5468rule__Assertion__ArgumentsAssignment_0_1_3_0
5469 @init {
5470 int stackSize = keepStackSize();
5471 }
5472:
5473 (
5474 { before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_0_0()); }
5475 ruleAssertionArgument
5476 { after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_0_0()); }
5477 )
5478;
5479finally {
5480 restoreStackSize(stackSize);
5481}
5482
5483rule__Assertion__ArgumentsAssignment_0_1_3_1_1
5484 @init {
5485 int stackSize = keepStackSize();
5486 }
5487:
5488 (
5489 { before(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_1_1_0()); }
5490 ruleAssertionArgument
5491 { after(grammarAccess.getAssertionAccess().getArgumentsAssertionArgumentParserRuleCall_0_1_3_1_1_0()); }
5492 )
5493;
5494finally {
5495 restoreStackSize(stackSize);
5496}
5497
5498rule__NodeAssertionArgument__NodeAssignment
5499 @init {
5500 int stackSize = keepStackSize();
5501 }
5502:
5503 (
5504 { before(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeCrossReference_0()); }
5505 (
5506 { before(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeQualifiedNameParserRuleCall_0_1()); }
5507 ruleQualifiedName
5508 { after(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeQualifiedNameParserRuleCall_0_1()); }
5509 )
5510 { after(grammarAccess.getNodeAssertionArgumentAccess().getNodeNodeCrossReference_0()); }
5511 )
5512;
5513finally {
5514 restoreStackSize(stackSize);
5515}
5516
5517rule__ConstantAssertionArgument__ConstantAssignment
5518 @init {
5519 int stackSize = keepStackSize();
5520 }
5521:
5522 (
5523 { before(grammarAccess.getConstantAssertionArgumentAccess().getConstantConstantParserRuleCall_0()); }
5524 ruleConstant
5525 { after(grammarAccess.getConstantAssertionArgumentAccess().getConstantConstantParserRuleCall_0()); }
5526 )
5527;
5528finally {
5529 restoreStackSize(stackSize);
5530}
5531
5532rule__NodeValueAssertion__NodeAssignment_0
5533 @init {
5534 int stackSize = keepStackSize();
5535 }
5536:
5537 (
5538 { before(grammarAccess.getNodeValueAssertionAccess().getNodeNodeCrossReference_0_0()); }
5539 (
5540 { before(grammarAccess.getNodeValueAssertionAccess().getNodeNodeQualifiedNameParserRuleCall_0_0_1()); }
5541 ruleQualifiedName
5542 { after(grammarAccess.getNodeValueAssertionAccess().getNodeNodeQualifiedNameParserRuleCall_0_0_1()); }
5543 )
5544 { after(grammarAccess.getNodeValueAssertionAccess().getNodeNodeCrossReference_0_0()); }
5545 )
5546;
5547finally {
5548 restoreStackSize(stackSize);
5549}
5550
5551rule__NodeValueAssertion__ValueAssignment_2
5552 @init {
5553 int stackSize = keepStackSize();
5554 }
5555:
5556 (
5557 { before(grammarAccess.getNodeValueAssertionAccess().getValueConstantParserRuleCall_2_0()); }
5558 ruleConstant
5559 { after(grammarAccess.getNodeValueAssertionAccess().getValueConstantParserRuleCall_2_0()); }
5560 )
5561;
5562finally {
5563 restoreStackSize(stackSize);
5564}
5565
5566rule__IntConstant__IntValueAssignment
5567 @init {
5568 int stackSize = keepStackSize();
5569 }
5570:
5571 (
5572 { before(grammarAccess.getIntConstantAccess().getIntValueIntegerParserRuleCall_0()); }
5573 ruleInteger
5574 { after(grammarAccess.getIntConstantAccess().getIntValueIntegerParserRuleCall_0()); }
5575 )
5576;
5577finally {
5578 restoreStackSize(stackSize);
5579}
5580
5581rule__RealConstant__RealValueAssignment
5582 @init {
5583 int stackSize = keepStackSize();
5584 }
5585:
5586 (
5587 { before(grammarAccess.getRealConstantAccess().getRealValueRealParserRuleCall_0()); }
5588 ruleReal
5589 { after(grammarAccess.getRealConstantAccess().getRealValueRealParserRuleCall_0()); }
5590 )
5591;
5592finally {
5593 restoreStackSize(stackSize);
5594}
5595
5596rule__StringConstant__StringValueAssignment
5597 @init {
5598 int stackSize = keepStackSize();
5599 }
5600:
5601 (
5602 { before(grammarAccess.getStringConstantAccess().getStringValueSTRINGTerminalRuleCall_0()); }
5603 RULE_STRING
5604 { after(grammarAccess.getStringConstantAccess().getStringValueSTRINGTerminalRuleCall_0()); }
5605 )
5606;
5607finally {
5608 restoreStackSize(stackSize);
5609}
5610
5611rule__ScopeDeclaration__TypeScopesAssignment_1
5612 @init {
5613 int stackSize = keepStackSize();
5614 }
5615:
5616 (
5617 { before(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); }
5618 ruleTypeScope
5619 { after(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); }
5620 )
5621;
5622finally {
5623 restoreStackSize(stackSize);
5624}
5625
5626rule__ScopeDeclaration__TypeScopesAssignment_2_1
5627 @init {
5628 int stackSize = keepStackSize();
5629 }
5630:
5631 (
5632 { before(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); }
5633 ruleTypeScope
5634 { after(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); }
5635 )
5636;
5637finally {
5638 restoreStackSize(stackSize);
5639}
5640
5641rule__TypeScope__TargetTypeAssignment_0
5642 @init {
5643 int stackSize = keepStackSize();
5644 }
5645:
5646 (
5647 { before(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); }
5648 (
5649 { before(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationIDTerminalRuleCall_0_0_1()); }
5650 RULE_ID
5651 { after(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationIDTerminalRuleCall_0_0_1()); }
5652 )
5653 { after(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); }
5654 )
5655;
5656finally {
5657 restoreStackSize(stackSize);
5658}
5659
5660rule__TypeScope__IncrementAssignment_1_0
5661 @init {
5662 int stackSize = keepStackSize();
5663 }
5664:
5665 (
5666 { before(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); }
5667 (
5668 { before(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); }
5669 '+='
5670 { after(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); }
5671 )
5672 { after(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); }
5673 )
5674;
5675finally {
5676 restoreStackSize(stackSize);
5677}
5678
5679rule__TypeScope__MultiplicityAssignment_2
5680 @init {
5681 int stackSize = keepStackSize();
5682 }
5683:
5684 (
5685 { before(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); }
5686 ruleDefiniteMultiplicity
5687 { after(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); }
5688 )
5689;
5690finally {
5691 restoreStackSize(stackSize);
5692}
5693
5694rule__RangeMultiplicity__LowerBoundAssignment_0
5695 @init {
5696 int stackSize = keepStackSize();
5697 }
5698:
5699 (
5700 { before(grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); }
5701 RULE_INT
5702 { after(grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); }
5703 )
5704;
5705finally {
5706 restoreStackSize(stackSize);
5707}
5708
5709rule__RangeMultiplicity__UpperBoundAssignment_2
5710 @init {
5711 int stackSize = keepStackSize();
5712 }
5713:
5714 (
5715 { before(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); }
5716 ruleUpperBound
5717 { after(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); }
5718 )
5719;
5720finally {
5721 restoreStackSize(stackSize);
5722}
5723
5724rule__ExactMultiplicity__ExactValueAssignment
5725 @init {
5726 int stackSize = keepStackSize();
5727 }
5728:
5729 (
5730 { before(grammarAccess.getExactMultiplicityAccess().getExactValueINTTerminalRuleCall_0()); }
5731 RULE_INT
5732 { after(grammarAccess.getExactMultiplicityAccess().getExactValueINTTerminalRuleCall_0()); }
5733 )
5734;
5735finally {
5736 restoreStackSize(stackSize);
5737}
5738
5739RULE_ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
5740
5741RULE_EXPONENTIAL : RULE_INT ('e'|'E') ('+'|'-')? RULE_INT;
5742
5743RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"';
5744
5745RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\'';
5746
5747RULE_SL_COMMENT : ('%'|'//') ~(('\n'|'\r'))* ('\r'? '\n')?;
5748
5749RULE_INT : ('0'..'9')+;
5750
5751RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
5752
5753RULE_WS : (' '|'\t'|'\r'|'\n')+;
5754
5755RULE_ANY_OTHER : .;
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-09-06 08:54:56 +0000