diff options
Diffstat (limited to 'Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g')
-rw-r--r-- | Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g | 8273 |
1 files changed, 8254 insertions, 19 deletions
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g b/Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g index 08fa0536..a3f72367 100644 --- a/Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g +++ b/Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g | |||
@@ -90,34 +90,34 @@ ruleCommand | |||
90 | } | 90 | } |
91 | : | 91 | : |
92 | ( | 92 | ( |
93 | { before(grammarAccess.getCommandAccess().getDeclarationParserRuleCall()); } | 93 | { before(grammarAccess.getCommandAccess().getAlternatives()); } |
94 | ruleDeclaration | 94 | (rule__Command__Alternatives) |
95 | { after(grammarAccess.getCommandAccess().getDeclarationParserRuleCall()); } | 95 | { after(grammarAccess.getCommandAccess().getAlternatives()); } |
96 | ) | 96 | ) |
97 | ; | 97 | ; |
98 | finally { | 98 | finally { |
99 | restoreStackSize(stackSize); | 99 | restoreStackSize(stackSize); |
100 | } | 100 | } |
101 | 101 | ||
102 | // Entry rule entryRuleDeclaration | 102 | // Entry rule entryRuleQualifiedName |
103 | entryRuleDeclaration | 103 | entryRuleQualifiedName |
104 | : | 104 | : |
105 | { before(grammarAccess.getDeclarationRule()); } | 105 | { before(grammarAccess.getQualifiedNameRule()); } |
106 | ruleDeclaration | 106 | ruleQualifiedName |
107 | { after(grammarAccess.getDeclarationRule()); } | 107 | { after(grammarAccess.getQualifiedNameRule()); } |
108 | EOF | 108 | EOF |
109 | ; | 109 | ; |
110 | 110 | ||
111 | // Rule Declaration | 111 | // Rule QualifiedName |
112 | ruleDeclaration | 112 | ruleQualifiedName |
113 | @init { | 113 | @init { |
114 | int stackSize = keepStackSize(); | 114 | int stackSize = keepStackSize(); |
115 | } | 115 | } |
116 | : | 116 | : |
117 | ( | 117 | ( |
118 | { before(grammarAccess.getDeclarationAccess().getMetamodelDeclarationParserRuleCall()); } | 118 | { before(grammarAccess.getQualifiedNameAccess().getGroup()); } |
119 | ruleMetamodelDeclaration | 119 | (rule__QualifiedName__Group__0) |
120 | { after(grammarAccess.getDeclarationAccess().getMetamodelDeclarationParserRuleCall()); } | 120 | { after(grammarAccess.getQualifiedNameAccess().getGroup()); } |
121 | ) | 121 | ) |
122 | ; | 122 | ; |
123 | finally { | 123 | finally { |
@@ -199,6 +199,131 @@ finally { | |||
199 | restoreStackSize(stackSize); | 199 | restoreStackSize(stackSize); |
200 | } | 200 | } |
201 | 201 | ||
202 | // Entry rule entryRuleDeclaration | ||
203 | entryRuleDeclaration | ||
204 | : | ||
205 | { before(grammarAccess.getDeclarationRule()); } | ||
206 | ruleDeclaration | ||
207 | { after(grammarAccess.getDeclarationRule()); } | ||
208 | EOF | ||
209 | ; | ||
210 | |||
211 | // Rule Declaration | ||
212 | ruleDeclaration | ||
213 | @init { | ||
214 | int stackSize = keepStackSize(); | ||
215 | } | ||
216 | : | ||
217 | ( | ||
218 | { before(grammarAccess.getDeclarationAccess().getAlternatives()); } | ||
219 | (rule__Declaration__Alternatives) | ||
220 | { after(grammarAccess.getDeclarationAccess().getAlternatives()); } | ||
221 | ) | ||
222 | ; | ||
223 | finally { | ||
224 | restoreStackSize(stackSize); | ||
225 | } | ||
226 | |||
227 | // Entry rule entryRuleFileSpecification | ||
228 | entryRuleFileSpecification | ||
229 | : | ||
230 | { before(grammarAccess.getFileSpecificationRule()); } | ||
231 | ruleFileSpecification | ||
232 | { after(grammarAccess.getFileSpecificationRule()); } | ||
233 | EOF | ||
234 | ; | ||
235 | |||
236 | // Rule FileSpecification | ||
237 | ruleFileSpecification | ||
238 | @init { | ||
239 | int stackSize = keepStackSize(); | ||
240 | } | ||
241 | : | ||
242 | ( | ||
243 | { before(grammarAccess.getFileSpecificationAccess().getPathAssignment()); } | ||
244 | (rule__FileSpecification__PathAssignment) | ||
245 | { after(grammarAccess.getFileSpecificationAccess().getPathAssignment()); } | ||
246 | ) | ||
247 | ; | ||
248 | finally { | ||
249 | restoreStackSize(stackSize); | ||
250 | } | ||
251 | |||
252 | // Entry rule entryRuleFileDeclaration | ||
253 | entryRuleFileDeclaration | ||
254 | : | ||
255 | { before(grammarAccess.getFileDeclarationRule()); } | ||
256 | ruleFileDeclaration | ||
257 | { after(grammarAccess.getFileDeclarationRule()); } | ||
258 | EOF | ||
259 | ; | ||
260 | |||
261 | // Rule FileDeclaration | ||
262 | ruleFileDeclaration | ||
263 | @init { | ||
264 | int stackSize = keepStackSize(); | ||
265 | } | ||
266 | : | ||
267 | ( | ||
268 | { before(grammarAccess.getFileDeclarationAccess().getGroup()); } | ||
269 | (rule__FileDeclaration__Group__0) | ||
270 | { after(grammarAccess.getFileDeclarationAccess().getGroup()); } | ||
271 | ) | ||
272 | ; | ||
273 | finally { | ||
274 | restoreStackSize(stackSize); | ||
275 | } | ||
276 | |||
277 | // Entry rule entryRuleFileReference | ||
278 | entryRuleFileReference | ||
279 | : | ||
280 | { before(grammarAccess.getFileReferenceRule()); } | ||
281 | ruleFileReference | ||
282 | { after(grammarAccess.getFileReferenceRule()); } | ||
283 | EOF | ||
284 | ; | ||
285 | |||
286 | // Rule FileReference | ||
287 | ruleFileReference | ||
288 | @init { | ||
289 | int stackSize = keepStackSize(); | ||
290 | } | ||
291 | : | ||
292 | ( | ||
293 | { before(grammarAccess.getFileReferenceAccess().getReferredAssignment()); } | ||
294 | (rule__FileReference__ReferredAssignment) | ||
295 | { after(grammarAccess.getFileReferenceAccess().getReferredAssignment()); } | ||
296 | ) | ||
297 | ; | ||
298 | finally { | ||
299 | restoreStackSize(stackSize); | ||
300 | } | ||
301 | |||
302 | // Entry rule entryRuleFile | ||
303 | entryRuleFile | ||
304 | : | ||
305 | { before(grammarAccess.getFileRule()); } | ||
306 | ruleFile | ||
307 | { after(grammarAccess.getFileRule()); } | ||
308 | EOF | ||
309 | ; | ||
310 | |||
311 | // Rule File | ||
312 | ruleFile | ||
313 | @init { | ||
314 | int stackSize = keepStackSize(); | ||
315 | } | ||
316 | : | ||
317 | ( | ||
318 | { before(grammarAccess.getFileAccess().getAlternatives()); } | ||
319 | (rule__File__Alternatives) | ||
320 | { after(grammarAccess.getFileAccess().getAlternatives()); } | ||
321 | ) | ||
322 | ; | ||
323 | finally { | ||
324 | restoreStackSize(stackSize); | ||
325 | } | ||
326 | |||
202 | // Entry rule entryRuleMetamodelSpecification | 327 | // Entry rule entryRuleMetamodelSpecification |
203 | entryRuleMetamodelSpecification | 328 | entryRuleMetamodelSpecification |
204 | : | 329 | : |
@@ -349,6 +474,1093 @@ finally { | |||
349 | restoreStackSize(stackSize); | 474 | restoreStackSize(stackSize); |
350 | } | 475 | } |
351 | 476 | ||
477 | // Entry rule entryRuleMetamodel | ||
478 | entryRuleMetamodel | ||
479 | : | ||
480 | { before(grammarAccess.getMetamodelRule()); } | ||
481 | ruleMetamodel | ||
482 | { after(grammarAccess.getMetamodelRule()); } | ||
483 | EOF | ||
484 | ; | ||
485 | |||
486 | // Rule Metamodel | ||
487 | ruleMetamodel | ||
488 | @init { | ||
489 | int stackSize = keepStackSize(); | ||
490 | } | ||
491 | : | ||
492 | ( | ||
493 | { before(grammarAccess.getMetamodelAccess().getAlternatives()); } | ||
494 | (rule__Metamodel__Alternatives) | ||
495 | { after(grammarAccess.getMetamodelAccess().getAlternatives()); } | ||
496 | ) | ||
497 | ; | ||
498 | finally { | ||
499 | restoreStackSize(stackSize); | ||
500 | } | ||
501 | |||
502 | // Entry rule entryRulePartialModelSpecification | ||
503 | entryRulePartialModelSpecification | ||
504 | : | ||
505 | { before(grammarAccess.getPartialModelSpecificationRule()); } | ||
506 | rulePartialModelSpecification | ||
507 | { after(grammarAccess.getPartialModelSpecificationRule()); } | ||
508 | EOF | ||
509 | ; | ||
510 | |||
511 | // Rule PartialModelSpecification | ||
512 | rulePartialModelSpecification | ||
513 | @init { | ||
514 | int stackSize = keepStackSize(); | ||
515 | } | ||
516 | : | ||
517 | ( | ||
518 | { before(grammarAccess.getPartialModelSpecificationAccess().getGroup()); } | ||
519 | (rule__PartialModelSpecification__Group__0) | ||
520 | { after(grammarAccess.getPartialModelSpecificationAccess().getGroup()); } | ||
521 | ) | ||
522 | ; | ||
523 | finally { | ||
524 | restoreStackSize(stackSize); | ||
525 | } | ||
526 | |||
527 | // Entry rule entryRulePartialModelEntry | ||
528 | entryRulePartialModelEntry | ||
529 | : | ||
530 | { before(grammarAccess.getPartialModelEntryRule()); } | ||
531 | rulePartialModelEntry | ||
532 | { after(grammarAccess.getPartialModelEntryRule()); } | ||
533 | EOF | ||
534 | ; | ||
535 | |||
536 | // Rule PartialModelEntry | ||
537 | rulePartialModelEntry | ||
538 | @init { | ||
539 | int stackSize = keepStackSize(); | ||
540 | } | ||
541 | : | ||
542 | ( | ||
543 | { before(grammarAccess.getPartialModelEntryAccess().getAlternatives()); } | ||
544 | (rule__PartialModelEntry__Alternatives) | ||
545 | { after(grammarAccess.getPartialModelEntryAccess().getAlternatives()); } | ||
546 | ) | ||
547 | ; | ||
548 | finally { | ||
549 | restoreStackSize(stackSize); | ||
550 | } | ||
551 | |||
552 | // Entry rule entryRuleModelEntry | ||
553 | entryRuleModelEntry | ||
554 | : | ||
555 | { before(grammarAccess.getModelEntryRule()); } | ||
556 | ruleModelEntry | ||
557 | { after(grammarAccess.getModelEntryRule()); } | ||
558 | EOF | ||
559 | ; | ||
560 | |||
561 | // Rule ModelEntry | ||
562 | ruleModelEntry | ||
563 | @init { | ||
564 | int stackSize = keepStackSize(); | ||
565 | } | ||
566 | : | ||
567 | ( | ||
568 | { before(grammarAccess.getModelEntryAccess().getPathAssignment()); } | ||
569 | (rule__ModelEntry__PathAssignment) | ||
570 | { after(grammarAccess.getModelEntryAccess().getPathAssignment()); } | ||
571 | ) | ||
572 | ; | ||
573 | finally { | ||
574 | restoreStackSize(stackSize); | ||
575 | } | ||
576 | |||
577 | // Entry rule entryRuleFolderEntry | ||
578 | entryRuleFolderEntry | ||
579 | : | ||
580 | { before(grammarAccess.getFolderEntryRule()); } | ||
581 | ruleFolderEntry | ||
582 | { after(grammarAccess.getFolderEntryRule()); } | ||
583 | EOF | ||
584 | ; | ||
585 | |||
586 | // Rule FolderEntry | ||
587 | ruleFolderEntry | ||
588 | @init { | ||
589 | int stackSize = keepStackSize(); | ||
590 | } | ||
591 | : | ||
592 | ( | ||
593 | { before(grammarAccess.getFolderEntryAccess().getGroup()); } | ||
594 | (rule__FolderEntry__Group__0) | ||
595 | { after(grammarAccess.getFolderEntryAccess().getGroup()); } | ||
596 | ) | ||
597 | ; | ||
598 | finally { | ||
599 | restoreStackSize(stackSize); | ||
600 | } | ||
601 | |||
602 | // Entry rule entryRulePartialModelDeclaration | ||
603 | entryRulePartialModelDeclaration | ||
604 | : | ||
605 | { before(grammarAccess.getPartialModelDeclarationRule()); } | ||
606 | rulePartialModelDeclaration | ||
607 | { after(grammarAccess.getPartialModelDeclarationRule()); } | ||
608 | EOF | ||
609 | ; | ||
610 | |||
611 | // Rule PartialModelDeclaration | ||
612 | rulePartialModelDeclaration | ||
613 | @init { | ||
614 | int stackSize = keepStackSize(); | ||
615 | } | ||
616 | : | ||
617 | ( | ||
618 | { before(grammarAccess.getPartialModelDeclarationAccess().getGroup()); } | ||
619 | (rule__PartialModelDeclaration__Group__0) | ||
620 | { after(grammarAccess.getPartialModelDeclarationAccess().getGroup()); } | ||
621 | ) | ||
622 | ; | ||
623 | finally { | ||
624 | restoreStackSize(stackSize); | ||
625 | } | ||
626 | |||
627 | // Entry rule entryRulePartialModelReference | ||
628 | entryRulePartialModelReference | ||
629 | : | ||
630 | { before(grammarAccess.getPartialModelReferenceRule()); } | ||
631 | rulePartialModelReference | ||
632 | { after(grammarAccess.getPartialModelReferenceRule()); } | ||
633 | EOF | ||
634 | ; | ||
635 | |||
636 | // Rule PartialModelReference | ||
637 | rulePartialModelReference | ||
638 | @init { | ||
639 | int stackSize = keepStackSize(); | ||
640 | } | ||
641 | : | ||
642 | ( | ||
643 | { before(grammarAccess.getPartialModelReferenceAccess().getReferredAssignment()); } | ||
644 | (rule__PartialModelReference__ReferredAssignment) | ||
645 | { after(grammarAccess.getPartialModelReferenceAccess().getReferredAssignment()); } | ||
646 | ) | ||
647 | ; | ||
648 | finally { | ||
649 | restoreStackSize(stackSize); | ||
650 | } | ||
651 | |||
652 | // Entry rule entryRulePartialModel | ||
653 | entryRulePartialModel | ||
654 | : | ||
655 | { before(grammarAccess.getPartialModelRule()); } | ||
656 | rulePartialModel | ||
657 | { after(grammarAccess.getPartialModelRule()); } | ||
658 | EOF | ||
659 | ; | ||
660 | |||
661 | // Rule PartialModel | ||
662 | rulePartialModel | ||
663 | @init { | ||
664 | int stackSize = keepStackSize(); | ||
665 | } | ||
666 | : | ||
667 | ( | ||
668 | { before(grammarAccess.getPartialModelAccess().getAlternatives()); } | ||
669 | (rule__PartialModel__Alternatives) | ||
670 | { after(grammarAccess.getPartialModelAccess().getAlternatives()); } | ||
671 | ) | ||
672 | ; | ||
673 | finally { | ||
674 | restoreStackSize(stackSize); | ||
675 | } | ||
676 | |||
677 | // Entry rule entryRulePatternSpecification | ||
678 | entryRulePatternSpecification | ||
679 | : | ||
680 | { before(grammarAccess.getPatternSpecificationRule()); } | ||
681 | rulePatternSpecification | ||
682 | { after(grammarAccess.getPatternSpecificationRule()); } | ||
683 | EOF | ||
684 | ; | ||
685 | |||
686 | // Rule PatternSpecification | ||
687 | rulePatternSpecification | ||
688 | @init { | ||
689 | int stackSize = keepStackSize(); | ||
690 | } | ||
691 | : | ||
692 | ( | ||
693 | { before(grammarAccess.getPatternSpecificationAccess().getGroup()); } | ||
694 | (rule__PatternSpecification__Group__0) | ||
695 | { after(grammarAccess.getPatternSpecificationAccess().getGroup()); } | ||
696 | ) | ||
697 | ; | ||
698 | finally { | ||
699 | restoreStackSize(stackSize); | ||
700 | } | ||
701 | |||
702 | // Entry rule entryRulePatternEntry | ||
703 | entryRulePatternEntry | ||
704 | : | ||
705 | { before(grammarAccess.getPatternEntryRule()); } | ||
706 | rulePatternEntry | ||
707 | { after(grammarAccess.getPatternEntryRule()); } | ||
708 | EOF | ||
709 | ; | ||
710 | |||
711 | // Rule PatternEntry | ||
712 | rulePatternEntry | ||
713 | @init { | ||
714 | int stackSize = keepStackSize(); | ||
715 | } | ||
716 | : | ||
717 | ( | ||
718 | { before(grammarAccess.getPatternEntryAccess().getAlternatives()); } | ||
719 | (rule__PatternEntry__Alternatives) | ||
720 | { after(grammarAccess.getPatternEntryAccess().getAlternatives()); } | ||
721 | ) | ||
722 | ; | ||
723 | finally { | ||
724 | restoreStackSize(stackSize); | ||
725 | } | ||
726 | |||
727 | // Entry rule entryRuleAllPatternEntry | ||
728 | entryRuleAllPatternEntry | ||
729 | : | ||
730 | { before(grammarAccess.getAllPatternEntryRule()); } | ||
731 | ruleAllPatternEntry | ||
732 | { after(grammarAccess.getAllPatternEntryRule()); } | ||
733 | EOF | ||
734 | ; | ||
735 | |||
736 | // Rule AllPatternEntry | ||
737 | ruleAllPatternEntry | ||
738 | @init { | ||
739 | int stackSize = keepStackSize(); | ||
740 | } | ||
741 | : | ||
742 | ( | ||
743 | { before(grammarAccess.getAllPatternEntryAccess().getGroup()); } | ||
744 | (rule__AllPatternEntry__Group__0) | ||
745 | { after(grammarAccess.getAllPatternEntryAccess().getGroup()); } | ||
746 | ) | ||
747 | ; | ||
748 | finally { | ||
749 | restoreStackSize(stackSize); | ||
750 | } | ||
751 | |||
752 | // Entry rule entryRulePatternElement | ||
753 | entryRulePatternElement | ||
754 | : | ||
755 | { before(grammarAccess.getPatternElementRule()); } | ||
756 | rulePatternElement | ||
757 | { after(grammarAccess.getPatternElementRule()); } | ||
758 | EOF | ||
759 | ; | ||
760 | |||
761 | // Rule PatternElement | ||
762 | rulePatternElement | ||
763 | @init { | ||
764 | int stackSize = keepStackSize(); | ||
765 | } | ||
766 | : | ||
767 | ( | ||
768 | { before(grammarAccess.getPatternElementAccess().getGroup()); } | ||
769 | (rule__PatternElement__Group__0) | ||
770 | { after(grammarAccess.getPatternElementAccess().getGroup()); } | ||
771 | ) | ||
772 | ; | ||
773 | finally { | ||
774 | restoreStackSize(stackSize); | ||
775 | } | ||
776 | |||
777 | // Entry rule entryRuleGraphPatternDeclaration | ||
778 | entryRuleGraphPatternDeclaration | ||
779 | : | ||
780 | { before(grammarAccess.getGraphPatternDeclarationRule()); } | ||
781 | ruleGraphPatternDeclaration | ||
782 | { after(grammarAccess.getGraphPatternDeclarationRule()); } | ||
783 | EOF | ||
784 | ; | ||
785 | |||
786 | // Rule GraphPatternDeclaration | ||
787 | ruleGraphPatternDeclaration | ||
788 | @init { | ||
789 | int stackSize = keepStackSize(); | ||
790 | } | ||
791 | : | ||
792 | ( | ||
793 | { before(grammarAccess.getGraphPatternDeclarationAccess().getGroup()); } | ||
794 | (rule__GraphPatternDeclaration__Group__0) | ||
795 | { after(grammarAccess.getGraphPatternDeclarationAccess().getGroup()); } | ||
796 | ) | ||
797 | ; | ||
798 | finally { | ||
799 | restoreStackSize(stackSize); | ||
800 | } | ||
801 | |||
802 | // Entry rule entryRuleGraphPatternReference | ||
803 | entryRuleGraphPatternReference | ||
804 | : | ||
805 | { before(grammarAccess.getGraphPatternReferenceRule()); } | ||
806 | ruleGraphPatternReference | ||
807 | { after(grammarAccess.getGraphPatternReferenceRule()); } | ||
808 | EOF | ||
809 | ; | ||
810 | |||
811 | // Rule GraphPatternReference | ||
812 | ruleGraphPatternReference | ||
813 | @init { | ||
814 | int stackSize = keepStackSize(); | ||
815 | } | ||
816 | : | ||
817 | ( | ||
818 | { before(grammarAccess.getGraphPatternReferenceAccess().getReferredAssignment()); } | ||
819 | (rule__GraphPatternReference__ReferredAssignment) | ||
820 | { after(grammarAccess.getGraphPatternReferenceAccess().getReferredAssignment()); } | ||
821 | ) | ||
822 | ; | ||
823 | finally { | ||
824 | restoreStackSize(stackSize); | ||
825 | } | ||
826 | |||
827 | // Entry rule entryRuleGraphPattern | ||
828 | entryRuleGraphPattern | ||
829 | : | ||
830 | { before(grammarAccess.getGraphPatternRule()); } | ||
831 | ruleGraphPattern | ||
832 | { after(grammarAccess.getGraphPatternRule()); } | ||
833 | EOF | ||
834 | ; | ||
835 | |||
836 | // Rule GraphPattern | ||
837 | ruleGraphPattern | ||
838 | @init { | ||
839 | int stackSize = keepStackSize(); | ||
840 | } | ||
841 | : | ||
842 | ( | ||
843 | { before(grammarAccess.getGraphPatternAccess().getAlternatives()); } | ||
844 | (rule__GraphPattern__Alternatives) | ||
845 | { after(grammarAccess.getGraphPatternAccess().getAlternatives()); } | ||
846 | ) | ||
847 | ; | ||
848 | finally { | ||
849 | restoreStackSize(stackSize); | ||
850 | } | ||
851 | |||
852 | // Entry rule entryRuleConfigSpecification | ||
853 | entryRuleConfigSpecification | ||
854 | : | ||
855 | { before(grammarAccess.getConfigSpecificationRule()); } | ||
856 | ruleConfigSpecification | ||
857 | { after(grammarAccess.getConfigSpecificationRule()); } | ||
858 | EOF | ||
859 | ; | ||
860 | |||
861 | // Rule ConfigSpecification | ||
862 | ruleConfigSpecification | ||
863 | @init { | ||
864 | int stackSize = keepStackSize(); | ||
865 | } | ||
866 | : | ||
867 | ( | ||
868 | { before(grammarAccess.getConfigSpecificationAccess().getGroup()); } | ||
869 | (rule__ConfigSpecification__Group__0) | ||
870 | { after(grammarAccess.getConfigSpecificationAccess().getGroup()); } | ||
871 | ) | ||
872 | ; | ||
873 | finally { | ||
874 | restoreStackSize(stackSize); | ||
875 | } | ||
876 | |||
877 | // Entry rule entryRuleConfigDeclaration | ||
878 | entryRuleConfigDeclaration | ||
879 | : | ||
880 | { before(grammarAccess.getConfigDeclarationRule()); } | ||
881 | ruleConfigDeclaration | ||
882 | { after(grammarAccess.getConfigDeclarationRule()); } | ||
883 | EOF | ||
884 | ; | ||
885 | |||
886 | // Rule ConfigDeclaration | ||
887 | ruleConfigDeclaration | ||
888 | @init { | ||
889 | int stackSize = keepStackSize(); | ||
890 | } | ||
891 | : | ||
892 | ( | ||
893 | { before(grammarAccess.getConfigDeclarationAccess().getGroup()); } | ||
894 | (rule__ConfigDeclaration__Group__0) | ||
895 | { after(grammarAccess.getConfigDeclarationAccess().getGroup()); } | ||
896 | ) | ||
897 | ; | ||
898 | finally { | ||
899 | restoreStackSize(stackSize); | ||
900 | } | ||
901 | |||
902 | // Entry rule entryRuleConfigEntry | ||
903 | entryRuleConfigEntry | ||
904 | : | ||
905 | { before(grammarAccess.getConfigEntryRule()); } | ||
906 | ruleConfigEntry | ||
907 | { after(grammarAccess.getConfigEntryRule()); } | ||
908 | EOF | ||
909 | ; | ||
910 | |||
911 | // Rule ConfigEntry | ||
912 | ruleConfigEntry | ||
913 | @init { | ||
914 | int stackSize = keepStackSize(); | ||
915 | } | ||
916 | : | ||
917 | ( | ||
918 | { before(grammarAccess.getConfigEntryAccess().getGroup()); } | ||
919 | (rule__ConfigEntry__Group__0) | ||
920 | { after(grammarAccess.getConfigEntryAccess().getGroup()); } | ||
921 | ) | ||
922 | ; | ||
923 | finally { | ||
924 | restoreStackSize(stackSize); | ||
925 | } | ||
926 | |||
927 | // Entry rule entryRuleConfigReference | ||
928 | entryRuleConfigReference | ||
929 | : | ||
930 | { before(grammarAccess.getConfigReferenceRule()); } | ||
931 | ruleConfigReference | ||
932 | { after(grammarAccess.getConfigReferenceRule()); } | ||
933 | EOF | ||
934 | ; | ||
935 | |||
936 | // Rule ConfigReference | ||
937 | ruleConfigReference | ||
938 | @init { | ||
939 | int stackSize = keepStackSize(); | ||
940 | } | ||
941 | : | ||
942 | ( | ||
943 | { before(grammarAccess.getConfigReferenceAccess().getConfigAssignment()); } | ||
944 | (rule__ConfigReference__ConfigAssignment) | ||
945 | { after(grammarAccess.getConfigReferenceAccess().getConfigAssignment()); } | ||
946 | ) | ||
947 | ; | ||
948 | finally { | ||
949 | restoreStackSize(stackSize); | ||
950 | } | ||
951 | |||
952 | // Entry rule entryRuleConfig | ||
953 | entryRuleConfig | ||
954 | : | ||
955 | { before(grammarAccess.getConfigRule()); } | ||
956 | ruleConfig | ||
957 | { after(grammarAccess.getConfigRule()); } | ||
958 | EOF | ||
959 | ; | ||
960 | |||
961 | // Rule Config | ||
962 | ruleConfig | ||
963 | @init { | ||
964 | int stackSize = keepStackSize(); | ||
965 | } | ||
966 | : | ||
967 | ( | ||
968 | { before(grammarAccess.getConfigAccess().getAlternatives()); } | ||
969 | (rule__Config__Alternatives) | ||
970 | { after(grammarAccess.getConfigAccess().getAlternatives()); } | ||
971 | ) | ||
972 | ; | ||
973 | finally { | ||
974 | restoreStackSize(stackSize); | ||
975 | } | ||
976 | |||
977 | // Entry rule entryRuleScopeSpecification | ||
978 | entryRuleScopeSpecification | ||
979 | : | ||
980 | { before(grammarAccess.getScopeSpecificationRule()); } | ||
981 | ruleScopeSpecification | ||
982 | { after(grammarAccess.getScopeSpecificationRule()); } | ||
983 | EOF | ||
984 | ; | ||
985 | |||
986 | // Rule ScopeSpecification | ||
987 | ruleScopeSpecification | ||
988 | @init { | ||
989 | int stackSize = keepStackSize(); | ||
990 | } | ||
991 | : | ||
992 | ( | ||
993 | { before(grammarAccess.getScopeSpecificationAccess().getGroup()); } | ||
994 | (rule__ScopeSpecification__Group__0) | ||
995 | { after(grammarAccess.getScopeSpecificationAccess().getGroup()); } | ||
996 | ) | ||
997 | ; | ||
998 | finally { | ||
999 | restoreStackSize(stackSize); | ||
1000 | } | ||
1001 | |||
1002 | // Entry rule entryRuleTypeScope | ||
1003 | entryRuleTypeScope | ||
1004 | : | ||
1005 | { before(grammarAccess.getTypeScopeRule()); } | ||
1006 | ruleTypeScope | ||
1007 | { after(grammarAccess.getTypeScopeRule()); } | ||
1008 | EOF | ||
1009 | ; | ||
1010 | |||
1011 | // Rule TypeScope | ||
1012 | ruleTypeScope | ||
1013 | @init { | ||
1014 | int stackSize = keepStackSize(); | ||
1015 | } | ||
1016 | : | ||
1017 | ( | ||
1018 | { before(grammarAccess.getTypeScopeAccess().getAlternatives()); } | ||
1019 | (rule__TypeScope__Alternatives) | ||
1020 | { after(grammarAccess.getTypeScopeAccess().getAlternatives()); } | ||
1021 | ) | ||
1022 | ; | ||
1023 | finally { | ||
1024 | restoreStackSize(stackSize); | ||
1025 | } | ||
1026 | |||
1027 | // Entry rule entryRuleClassTypeScope | ||
1028 | entryRuleClassTypeScope | ||
1029 | : | ||
1030 | { before(grammarAccess.getClassTypeScopeRule()); } | ||
1031 | ruleClassTypeScope | ||
1032 | { after(grammarAccess.getClassTypeScopeRule()); } | ||
1033 | EOF | ||
1034 | ; | ||
1035 | |||
1036 | // Rule ClassTypeScope | ||
1037 | ruleClassTypeScope | ||
1038 | @init { | ||
1039 | int stackSize = keepStackSize(); | ||
1040 | } | ||
1041 | : | ||
1042 | ( | ||
1043 | { before(grammarAccess.getClassTypeScopeAccess().getGroup()); } | ||
1044 | (rule__ClassTypeScope__Group__0) | ||
1045 | { after(grammarAccess.getClassTypeScopeAccess().getGroup()); } | ||
1046 | ) | ||
1047 | ; | ||
1048 | finally { | ||
1049 | restoreStackSize(stackSize); | ||
1050 | } | ||
1051 | |||
1052 | // Entry rule entryRuleObjectTypeScope | ||
1053 | entryRuleObjectTypeScope | ||
1054 | : | ||
1055 | { before(grammarAccess.getObjectTypeScopeRule()); } | ||
1056 | ruleObjectTypeScope | ||
1057 | { after(grammarAccess.getObjectTypeScopeRule()); } | ||
1058 | EOF | ||
1059 | ; | ||
1060 | |||
1061 | // Rule ObjectTypeScope | ||
1062 | ruleObjectTypeScope | ||
1063 | @init { | ||
1064 | int stackSize = keepStackSize(); | ||
1065 | } | ||
1066 | : | ||
1067 | ( | ||
1068 | { before(grammarAccess.getObjectTypeScopeAccess().getGroup()); } | ||
1069 | (rule__ObjectTypeScope__Group__0) | ||
1070 | { after(grammarAccess.getObjectTypeScopeAccess().getGroup()); } | ||
1071 | ) | ||
1072 | ; | ||
1073 | finally { | ||
1074 | restoreStackSize(stackSize); | ||
1075 | } | ||
1076 | |||
1077 | // Entry rule entryRuleIntegerTypeScope | ||
1078 | entryRuleIntegerTypeScope | ||
1079 | : | ||
1080 | { before(grammarAccess.getIntegerTypeScopeRule()); } | ||
1081 | ruleIntegerTypeScope | ||
1082 | { after(grammarAccess.getIntegerTypeScopeRule()); } | ||
1083 | EOF | ||
1084 | ; | ||
1085 | |||
1086 | // Rule IntegerTypeScope | ||
1087 | ruleIntegerTypeScope | ||
1088 | @init { | ||
1089 | int stackSize = keepStackSize(); | ||
1090 | } | ||
1091 | : | ||
1092 | ( | ||
1093 | { before(grammarAccess.getIntegerTypeScopeAccess().getGroup()); } | ||
1094 | (rule__IntegerTypeScope__Group__0) | ||
1095 | { after(grammarAccess.getIntegerTypeScopeAccess().getGroup()); } | ||
1096 | ) | ||
1097 | ; | ||
1098 | finally { | ||
1099 | restoreStackSize(stackSize); | ||
1100 | } | ||
1101 | |||
1102 | // Entry rule entryRuleRealTypeScope | ||
1103 | entryRuleRealTypeScope | ||
1104 | : | ||
1105 | { before(grammarAccess.getRealTypeScopeRule()); } | ||
1106 | ruleRealTypeScope | ||
1107 | { after(grammarAccess.getRealTypeScopeRule()); } | ||
1108 | EOF | ||
1109 | ; | ||
1110 | |||
1111 | // Rule RealTypeScope | ||
1112 | ruleRealTypeScope | ||
1113 | @init { | ||
1114 | int stackSize = keepStackSize(); | ||
1115 | } | ||
1116 | : | ||
1117 | ( | ||
1118 | { before(grammarAccess.getRealTypeScopeAccess().getGroup()); } | ||
1119 | (rule__RealTypeScope__Group__0) | ||
1120 | { after(grammarAccess.getRealTypeScopeAccess().getGroup()); } | ||
1121 | ) | ||
1122 | ; | ||
1123 | finally { | ||
1124 | restoreStackSize(stackSize); | ||
1125 | } | ||
1126 | |||
1127 | // Entry rule entryRuleStringTypeScope | ||
1128 | entryRuleStringTypeScope | ||
1129 | : | ||
1130 | { before(grammarAccess.getStringTypeScopeRule()); } | ||
1131 | ruleStringTypeScope | ||
1132 | { after(grammarAccess.getStringTypeScopeRule()); } | ||
1133 | EOF | ||
1134 | ; | ||
1135 | |||
1136 | // Rule StringTypeScope | ||
1137 | ruleStringTypeScope | ||
1138 | @init { | ||
1139 | int stackSize = keepStackSize(); | ||
1140 | } | ||
1141 | : | ||
1142 | ( | ||
1143 | { before(grammarAccess.getStringTypeScopeAccess().getGroup()); } | ||
1144 | (rule__StringTypeScope__Group__0) | ||
1145 | { after(grammarAccess.getStringTypeScopeAccess().getGroup()); } | ||
1146 | ) | ||
1147 | ; | ||
1148 | finally { | ||
1149 | restoreStackSize(stackSize); | ||
1150 | } | ||
1151 | |||
1152 | // Entry rule entryRuleClassReference | ||
1153 | entryRuleClassReference | ||
1154 | : | ||
1155 | { before(grammarAccess.getClassReferenceRule()); } | ||
1156 | ruleClassReference | ||
1157 | { after(grammarAccess.getClassReferenceRule()); } | ||
1158 | EOF | ||
1159 | ; | ||
1160 | |||
1161 | // Rule ClassReference | ||
1162 | ruleClassReference | ||
1163 | @init { | ||
1164 | int stackSize = keepStackSize(); | ||
1165 | } | ||
1166 | : | ||
1167 | ( | ||
1168 | { before(grammarAccess.getClassReferenceAccess().getGroup()); } | ||
1169 | (rule__ClassReference__Group__0) | ||
1170 | { after(grammarAccess.getClassReferenceAccess().getGroup()); } | ||
1171 | ) | ||
1172 | ; | ||
1173 | finally { | ||
1174 | restoreStackSize(stackSize); | ||
1175 | } | ||
1176 | |||
1177 | // Entry rule entryRuleObjectReference | ||
1178 | entryRuleObjectReference | ||
1179 | : | ||
1180 | { before(grammarAccess.getObjectReferenceRule()); } | ||
1181 | ruleObjectReference | ||
1182 | { after(grammarAccess.getObjectReferenceRule()); } | ||
1183 | EOF | ||
1184 | ; | ||
1185 | |||
1186 | // Rule ObjectReference | ||
1187 | ruleObjectReference | ||
1188 | @init { | ||
1189 | int stackSize = keepStackSize(); | ||
1190 | } | ||
1191 | : | ||
1192 | ( | ||
1193 | { before(grammarAccess.getObjectReferenceAccess().getGroup()); } | ||
1194 | (rule__ObjectReference__Group__0) | ||
1195 | { after(grammarAccess.getObjectReferenceAccess().getGroup()); } | ||
1196 | ) | ||
1197 | ; | ||
1198 | finally { | ||
1199 | restoreStackSize(stackSize); | ||
1200 | } | ||
1201 | |||
1202 | // Entry rule entryRuleIntegerReference | ||
1203 | entryRuleIntegerReference | ||
1204 | : | ||
1205 | { before(grammarAccess.getIntegerReferenceRule()); } | ||
1206 | ruleIntegerReference | ||
1207 | { after(grammarAccess.getIntegerReferenceRule()); } | ||
1208 | EOF | ||
1209 | ; | ||
1210 | |||
1211 | // Rule IntegerReference | ||
1212 | ruleIntegerReference | ||
1213 | @init { | ||
1214 | int stackSize = keepStackSize(); | ||
1215 | } | ||
1216 | : | ||
1217 | ( | ||
1218 | { before(grammarAccess.getIntegerReferenceAccess().getGroup()); } | ||
1219 | (rule__IntegerReference__Group__0) | ||
1220 | { after(grammarAccess.getIntegerReferenceAccess().getGroup()); } | ||
1221 | ) | ||
1222 | ; | ||
1223 | finally { | ||
1224 | restoreStackSize(stackSize); | ||
1225 | } | ||
1226 | |||
1227 | // Entry rule entryRuleRealReference | ||
1228 | entryRuleRealReference | ||
1229 | : | ||
1230 | { before(grammarAccess.getRealReferenceRule()); } | ||
1231 | ruleRealReference | ||
1232 | { after(grammarAccess.getRealReferenceRule()); } | ||
1233 | EOF | ||
1234 | ; | ||
1235 | |||
1236 | // Rule RealReference | ||
1237 | ruleRealReference | ||
1238 | @init { | ||
1239 | int stackSize = keepStackSize(); | ||
1240 | } | ||
1241 | : | ||
1242 | ( | ||
1243 | { before(grammarAccess.getRealReferenceAccess().getGroup()); } | ||
1244 | (rule__RealReference__Group__0) | ||
1245 | { after(grammarAccess.getRealReferenceAccess().getGroup()); } | ||
1246 | ) | ||
1247 | ; | ||
1248 | finally { | ||
1249 | restoreStackSize(stackSize); | ||
1250 | } | ||
1251 | |||
1252 | // Entry rule entryRuleStringReference | ||
1253 | entryRuleStringReference | ||
1254 | : | ||
1255 | { before(grammarAccess.getStringReferenceRule()); } | ||
1256 | ruleStringReference | ||
1257 | { after(grammarAccess.getStringReferenceRule()); } | ||
1258 | EOF | ||
1259 | ; | ||
1260 | |||
1261 | // Rule StringReference | ||
1262 | ruleStringReference | ||
1263 | @init { | ||
1264 | int stackSize = keepStackSize(); | ||
1265 | } | ||
1266 | : | ||
1267 | ( | ||
1268 | { before(grammarAccess.getStringReferenceAccess().getGroup()); } | ||
1269 | (rule__StringReference__Group__0) | ||
1270 | { after(grammarAccess.getStringReferenceAccess().getGroup()); } | ||
1271 | ) | ||
1272 | ; | ||
1273 | finally { | ||
1274 | restoreStackSize(stackSize); | ||
1275 | } | ||
1276 | |||
1277 | // Entry rule entryRuleExactNumber | ||
1278 | entryRuleExactNumber | ||
1279 | : | ||
1280 | { before(grammarAccess.getExactNumberRule()); } | ||
1281 | ruleExactNumber | ||
1282 | { after(grammarAccess.getExactNumberRule()); } | ||
1283 | EOF | ||
1284 | ; | ||
1285 | |||
1286 | // Rule ExactNumber | ||
1287 | ruleExactNumber | ||
1288 | @init { | ||
1289 | int stackSize = keepStackSize(); | ||
1290 | } | ||
1291 | : | ||
1292 | ( | ||
1293 | { before(grammarAccess.getExactNumberAccess().getAlternatives()); } | ||
1294 | (rule__ExactNumber__Alternatives) | ||
1295 | { after(grammarAccess.getExactNumberAccess().getAlternatives()); } | ||
1296 | ) | ||
1297 | ; | ||
1298 | finally { | ||
1299 | restoreStackSize(stackSize); | ||
1300 | } | ||
1301 | |||
1302 | // Entry rule entryRuleIntervallNumber | ||
1303 | entryRuleIntervallNumber | ||
1304 | : | ||
1305 | { before(grammarAccess.getIntervallNumberRule()); } | ||
1306 | ruleIntervallNumber | ||
1307 | { after(grammarAccess.getIntervallNumberRule()); } | ||
1308 | EOF | ||
1309 | ; | ||
1310 | |||
1311 | // Rule IntervallNumber | ||
1312 | ruleIntervallNumber | ||
1313 | @init { | ||
1314 | int stackSize = keepStackSize(); | ||
1315 | } | ||
1316 | : | ||
1317 | ( | ||
1318 | { before(grammarAccess.getIntervallNumberAccess().getGroup()); } | ||
1319 | (rule__IntervallNumber__Group__0) | ||
1320 | { after(grammarAccess.getIntervallNumberAccess().getGroup()); } | ||
1321 | ) | ||
1322 | ; | ||
1323 | finally { | ||
1324 | restoreStackSize(stackSize); | ||
1325 | } | ||
1326 | |||
1327 | // Entry rule entryRuleIntEnumberation | ||
1328 | entryRuleIntEnumberation | ||
1329 | : | ||
1330 | { before(grammarAccess.getIntEnumberationRule()); } | ||
1331 | ruleIntEnumberation | ||
1332 | { after(grammarAccess.getIntEnumberationRule()); } | ||
1333 | EOF | ||
1334 | ; | ||
1335 | |||
1336 | // Rule IntEnumberation | ||
1337 | ruleIntEnumberation | ||
1338 | @init { | ||
1339 | int stackSize = keepStackSize(); | ||
1340 | } | ||
1341 | : | ||
1342 | ( | ||
1343 | { before(grammarAccess.getIntEnumberationAccess().getGroup()); } | ||
1344 | (rule__IntEnumberation__Group__0) | ||
1345 | { after(grammarAccess.getIntEnumberationAccess().getGroup()); } | ||
1346 | ) | ||
1347 | ; | ||
1348 | finally { | ||
1349 | restoreStackSize(stackSize); | ||
1350 | } | ||
1351 | |||
1352 | // Entry rule entryRuleRealEnumeration | ||
1353 | entryRuleRealEnumeration | ||
1354 | : | ||
1355 | { before(grammarAccess.getRealEnumerationRule()); } | ||
1356 | ruleRealEnumeration | ||
1357 | { after(grammarAccess.getRealEnumerationRule()); } | ||
1358 | EOF | ||
1359 | ; | ||
1360 | |||
1361 | // Rule RealEnumeration | ||
1362 | ruleRealEnumeration | ||
1363 | @init { | ||
1364 | int stackSize = keepStackSize(); | ||
1365 | } | ||
1366 | : | ||
1367 | ( | ||
1368 | { before(grammarAccess.getRealEnumerationAccess().getGroup()); } | ||
1369 | (rule__RealEnumeration__Group__0) | ||
1370 | { after(grammarAccess.getRealEnumerationAccess().getGroup()); } | ||
1371 | ) | ||
1372 | ; | ||
1373 | finally { | ||
1374 | restoreStackSize(stackSize); | ||
1375 | } | ||
1376 | |||
1377 | // Entry rule entryRuleStringEnumeration | ||
1378 | entryRuleStringEnumeration | ||
1379 | : | ||
1380 | { before(grammarAccess.getStringEnumerationRule()); } | ||
1381 | ruleStringEnumeration | ||
1382 | { after(grammarAccess.getStringEnumerationRule()); } | ||
1383 | EOF | ||
1384 | ; | ||
1385 | |||
1386 | // Rule StringEnumeration | ||
1387 | ruleStringEnumeration | ||
1388 | @init { | ||
1389 | int stackSize = keepStackSize(); | ||
1390 | } | ||
1391 | : | ||
1392 | ( | ||
1393 | { before(grammarAccess.getStringEnumerationAccess().getGroup()); } | ||
1394 | (rule__StringEnumeration__Group__0) | ||
1395 | { after(grammarAccess.getStringEnumerationAccess().getGroup()); } | ||
1396 | ) | ||
1397 | ; | ||
1398 | finally { | ||
1399 | restoreStackSize(stackSize); | ||
1400 | } | ||
1401 | |||
1402 | // Entry rule entryRuleScopeDeclaration | ||
1403 | entryRuleScopeDeclaration | ||
1404 | : | ||
1405 | { before(grammarAccess.getScopeDeclarationRule()); } | ||
1406 | ruleScopeDeclaration | ||
1407 | { after(grammarAccess.getScopeDeclarationRule()); } | ||
1408 | EOF | ||
1409 | ; | ||
1410 | |||
1411 | // Rule ScopeDeclaration | ||
1412 | ruleScopeDeclaration | ||
1413 | @init { | ||
1414 | int stackSize = keepStackSize(); | ||
1415 | } | ||
1416 | : | ||
1417 | ( | ||
1418 | { before(grammarAccess.getScopeDeclarationAccess().getGroup()); } | ||
1419 | (rule__ScopeDeclaration__Group__0) | ||
1420 | { after(grammarAccess.getScopeDeclarationAccess().getGroup()); } | ||
1421 | ) | ||
1422 | ; | ||
1423 | finally { | ||
1424 | restoreStackSize(stackSize); | ||
1425 | } | ||
1426 | |||
1427 | // Entry rule entryRuleScopeReference | ||
1428 | entryRuleScopeReference | ||
1429 | : | ||
1430 | { before(grammarAccess.getScopeReferenceRule()); } | ||
1431 | ruleScopeReference | ||
1432 | { after(grammarAccess.getScopeReferenceRule()); } | ||
1433 | EOF | ||
1434 | ; | ||
1435 | |||
1436 | // Rule ScopeReference | ||
1437 | ruleScopeReference | ||
1438 | @init { | ||
1439 | int stackSize = keepStackSize(); | ||
1440 | } | ||
1441 | : | ||
1442 | ( | ||
1443 | { before(grammarAccess.getScopeReferenceAccess().getReferredAssignment()); } | ||
1444 | (rule__ScopeReference__ReferredAssignment) | ||
1445 | { after(grammarAccess.getScopeReferenceAccess().getReferredAssignment()); } | ||
1446 | ) | ||
1447 | ; | ||
1448 | finally { | ||
1449 | restoreStackSize(stackSize); | ||
1450 | } | ||
1451 | |||
1452 | // Entry rule entryRuleScope | ||
1453 | entryRuleScope | ||
1454 | : | ||
1455 | { before(grammarAccess.getScopeRule()); } | ||
1456 | ruleScope | ||
1457 | { after(grammarAccess.getScopeRule()); } | ||
1458 | EOF | ||
1459 | ; | ||
1460 | |||
1461 | // Rule Scope | ||
1462 | ruleScope | ||
1463 | @init { | ||
1464 | int stackSize = keepStackSize(); | ||
1465 | } | ||
1466 | : | ||
1467 | ( | ||
1468 | { before(grammarAccess.getScopeAccess().getAlternatives()); } | ||
1469 | (rule__Scope__Alternatives) | ||
1470 | { after(grammarAccess.getScopeAccess().getAlternatives()); } | ||
1471 | ) | ||
1472 | ; | ||
1473 | finally { | ||
1474 | restoreStackSize(stackSize); | ||
1475 | } | ||
1476 | |||
1477 | // Entry rule entryRuleTask | ||
1478 | entryRuleTask | ||
1479 | : | ||
1480 | { before(grammarAccess.getTaskRule()); } | ||
1481 | ruleTask | ||
1482 | { after(grammarAccess.getTaskRule()); } | ||
1483 | EOF | ||
1484 | ; | ||
1485 | |||
1486 | // Rule Task | ||
1487 | ruleTask | ||
1488 | @init { | ||
1489 | int stackSize = keepStackSize(); | ||
1490 | } | ||
1491 | : | ||
1492 | ( | ||
1493 | { before(grammarAccess.getTaskAccess().getGenerationTaskParserRuleCall()); } | ||
1494 | ruleGenerationTask | ||
1495 | { after(grammarAccess.getTaskAccess().getGenerationTaskParserRuleCall()); } | ||
1496 | ) | ||
1497 | ; | ||
1498 | finally { | ||
1499 | restoreStackSize(stackSize); | ||
1500 | } | ||
1501 | |||
1502 | // Entry rule entryRuleGenerationTask | ||
1503 | entryRuleGenerationTask | ||
1504 | : | ||
1505 | { before(grammarAccess.getGenerationTaskRule()); } | ||
1506 | ruleGenerationTask | ||
1507 | { after(grammarAccess.getGenerationTaskRule()); } | ||
1508 | EOF | ||
1509 | ; | ||
1510 | |||
1511 | // Rule GenerationTask | ||
1512 | ruleGenerationTask | ||
1513 | @init { | ||
1514 | int stackSize = keepStackSize(); | ||
1515 | } | ||
1516 | : | ||
1517 | ( | ||
1518 | { before(grammarAccess.getGenerationTaskAccess().getGroup()); } | ||
1519 | (rule__GenerationTask__Group__0) | ||
1520 | { after(grammarAccess.getGenerationTaskAccess().getGroup()); } | ||
1521 | ) | ||
1522 | ; | ||
1523 | finally { | ||
1524 | restoreStackSize(stackSize); | ||
1525 | } | ||
1526 | |||
1527 | // Rule Solver | ||
1528 | ruleSolver | ||
1529 | @init { | ||
1530 | int stackSize = keepStackSize(); | ||
1531 | } | ||
1532 | : | ||
1533 | ( | ||
1534 | { before(grammarAccess.getSolverAccess().getAlternatives()); } | ||
1535 | (rule__Solver__Alternatives) | ||
1536 | { after(grammarAccess.getSolverAccess().getAlternatives()); } | ||
1537 | ) | ||
1538 | ; | ||
1539 | finally { | ||
1540 | restoreStackSize(stackSize); | ||
1541 | } | ||
1542 | |||
1543 | rule__Command__Alternatives | ||
1544 | @init { | ||
1545 | int stackSize = keepStackSize(); | ||
1546 | } | ||
1547 | : | ||
1548 | ( | ||
1549 | { before(grammarAccess.getCommandAccess().getDeclarationParserRuleCall_0()); } | ||
1550 | ruleDeclaration | ||
1551 | { after(grammarAccess.getCommandAccess().getDeclarationParserRuleCall_0()); } | ||
1552 | ) | ||
1553 | | | ||
1554 | ( | ||
1555 | { before(grammarAccess.getCommandAccess().getTaskParserRuleCall_1()); } | ||
1556 | ruleTask | ||
1557 | { after(grammarAccess.getCommandAccess().getTaskParserRuleCall_1()); } | ||
1558 | ) | ||
1559 | ; | ||
1560 | finally { | ||
1561 | restoreStackSize(stackSize); | ||
1562 | } | ||
1563 | |||
352 | rule__Import__Alternatives | 1564 | rule__Import__Alternatives |
353 | @init { | 1565 | @init { |
354 | int stackSize = keepStackSize(); | 1566 | int stackSize = keepStackSize(); |
@@ -370,6 +1582,72 @@ finally { | |||
370 | restoreStackSize(stackSize); | 1582 | restoreStackSize(stackSize); |
371 | } | 1583 | } |
372 | 1584 | ||
1585 | rule__Declaration__Alternatives | ||
1586 | @init { | ||
1587 | int stackSize = keepStackSize(); | ||
1588 | } | ||
1589 | : | ||
1590 | ( | ||
1591 | { before(grammarAccess.getDeclarationAccess().getFileDeclarationParserRuleCall_0()); } | ||
1592 | ruleFileDeclaration | ||
1593 | { after(grammarAccess.getDeclarationAccess().getFileDeclarationParserRuleCall_0()); } | ||
1594 | ) | ||
1595 | | | ||
1596 | ( | ||
1597 | { before(grammarAccess.getDeclarationAccess().getMetamodelDeclarationParserRuleCall_1()); } | ||
1598 | ruleMetamodelDeclaration | ||
1599 | { after(grammarAccess.getDeclarationAccess().getMetamodelDeclarationParserRuleCall_1()); } | ||
1600 | ) | ||
1601 | | | ||
1602 | ( | ||
1603 | { before(grammarAccess.getDeclarationAccess().getPartialModelDeclarationParserRuleCall_2()); } | ||
1604 | rulePartialModelDeclaration | ||
1605 | { after(grammarAccess.getDeclarationAccess().getPartialModelDeclarationParserRuleCall_2()); } | ||
1606 | ) | ||
1607 | | | ||
1608 | ( | ||
1609 | { before(grammarAccess.getDeclarationAccess().getGraphPatternDeclarationParserRuleCall_3()); } | ||
1610 | ruleGraphPatternDeclaration | ||
1611 | { after(grammarAccess.getDeclarationAccess().getGraphPatternDeclarationParserRuleCall_3()); } | ||
1612 | ) | ||
1613 | | | ||
1614 | ( | ||
1615 | { before(grammarAccess.getDeclarationAccess().getConfigDeclarationParserRuleCall_4()); } | ||
1616 | ruleConfigDeclaration | ||
1617 | { after(grammarAccess.getDeclarationAccess().getConfigDeclarationParserRuleCall_4()); } | ||
1618 | ) | ||
1619 | | | ||
1620 | ( | ||
1621 | { before(grammarAccess.getDeclarationAccess().getScopeDeclarationParserRuleCall_5()); } | ||
1622 | ruleScopeDeclaration | ||
1623 | { after(grammarAccess.getDeclarationAccess().getScopeDeclarationParserRuleCall_5()); } | ||
1624 | ) | ||
1625 | ; | ||
1626 | finally { | ||
1627 | restoreStackSize(stackSize); | ||
1628 | } | ||
1629 | |||
1630 | rule__File__Alternatives | ||
1631 | @init { | ||
1632 | int stackSize = keepStackSize(); | ||
1633 | } | ||
1634 | : | ||
1635 | ( | ||
1636 | { before(grammarAccess.getFileAccess().getFileSpecificationParserRuleCall_0()); } | ||
1637 | ruleFileSpecification | ||
1638 | { after(grammarAccess.getFileAccess().getFileSpecificationParserRuleCall_0()); } | ||
1639 | ) | ||
1640 | | | ||
1641 | ( | ||
1642 | { before(grammarAccess.getFileAccess().getFileReferenceParserRuleCall_1()); } | ||
1643 | ruleFileReference | ||
1644 | { after(grammarAccess.getFileAccess().getFileReferenceParserRuleCall_1()); } | ||
1645 | ) | ||
1646 | ; | ||
1647 | finally { | ||
1648 | restoreStackSize(stackSize); | ||
1649 | } | ||
1650 | |||
373 | rule__MetamodelEntry__Alternatives | 1651 | rule__MetamodelEntry__Alternatives |
374 | @init { | 1652 | @init { |
375 | int stackSize = keepStackSize(); | 1653 | int stackSize = keepStackSize(); |
@@ -391,6 +1669,489 @@ finally { | |||
391 | restoreStackSize(stackSize); | 1669 | restoreStackSize(stackSize); |
392 | } | 1670 | } |
393 | 1671 | ||
1672 | rule__Metamodel__Alternatives | ||
1673 | @init { | ||
1674 | int stackSize = keepStackSize(); | ||
1675 | } | ||
1676 | : | ||
1677 | ( | ||
1678 | { before(grammarAccess.getMetamodelAccess().getMetamodelReferenceParserRuleCall_0()); } | ||
1679 | ruleMetamodelReference | ||
1680 | { after(grammarAccess.getMetamodelAccess().getMetamodelReferenceParserRuleCall_0()); } | ||
1681 | ) | ||
1682 | | | ||
1683 | ( | ||
1684 | { before(grammarAccess.getMetamodelAccess().getMetamodelSpecificationParserRuleCall_1()); } | ||
1685 | ruleMetamodelSpecification | ||
1686 | { after(grammarAccess.getMetamodelAccess().getMetamodelSpecificationParserRuleCall_1()); } | ||
1687 | ) | ||
1688 | ; | ||
1689 | finally { | ||
1690 | restoreStackSize(stackSize); | ||
1691 | } | ||
1692 | |||
1693 | rule__PartialModelEntry__Alternatives | ||
1694 | @init { | ||
1695 | int stackSize = keepStackSize(); | ||
1696 | } | ||
1697 | : | ||
1698 | ( | ||
1699 | { before(grammarAccess.getPartialModelEntryAccess().getModelEntryParserRuleCall_0()); } | ||
1700 | ruleModelEntry | ||
1701 | { after(grammarAccess.getPartialModelEntryAccess().getModelEntryParserRuleCall_0()); } | ||
1702 | ) | ||
1703 | | | ||
1704 | ( | ||
1705 | { before(grammarAccess.getPartialModelEntryAccess().getFolderEntryParserRuleCall_1()); } | ||
1706 | ruleFolderEntry | ||
1707 | { after(grammarAccess.getPartialModelEntryAccess().getFolderEntryParserRuleCall_1()); } | ||
1708 | ) | ||
1709 | ; | ||
1710 | finally { | ||
1711 | restoreStackSize(stackSize); | ||
1712 | } | ||
1713 | |||
1714 | rule__PartialModel__Alternatives | ||
1715 | @init { | ||
1716 | int stackSize = keepStackSize(); | ||
1717 | } | ||
1718 | : | ||
1719 | ( | ||
1720 | { before(grammarAccess.getPartialModelAccess().getPartialModelSpecificationParserRuleCall_0()); } | ||
1721 | rulePartialModelSpecification | ||
1722 | { after(grammarAccess.getPartialModelAccess().getPartialModelSpecificationParserRuleCall_0()); } | ||
1723 | ) | ||
1724 | | | ||
1725 | ( | ||
1726 | { before(grammarAccess.getPartialModelAccess().getPartialModelReferenceParserRuleCall_1()); } | ||
1727 | rulePartialModelReference | ||
1728 | { after(grammarAccess.getPartialModelAccess().getPartialModelReferenceParserRuleCall_1()); } | ||
1729 | ) | ||
1730 | ; | ||
1731 | finally { | ||
1732 | restoreStackSize(stackSize); | ||
1733 | } | ||
1734 | |||
1735 | rule__PatternEntry__Alternatives | ||
1736 | @init { | ||
1737 | int stackSize = keepStackSize(); | ||
1738 | } | ||
1739 | : | ||
1740 | ( | ||
1741 | { before(grammarAccess.getPatternEntryAccess().getPatternElementParserRuleCall_0()); } | ||
1742 | rulePatternElement | ||
1743 | { after(grammarAccess.getPatternEntryAccess().getPatternElementParserRuleCall_0()); } | ||
1744 | ) | ||
1745 | | | ||
1746 | ( | ||
1747 | { before(grammarAccess.getPatternEntryAccess().getAllPatternEntryParserRuleCall_1()); } | ||
1748 | ruleAllPatternEntry | ||
1749 | { after(grammarAccess.getPatternEntryAccess().getAllPatternEntryParserRuleCall_1()); } | ||
1750 | ) | ||
1751 | ; | ||
1752 | finally { | ||
1753 | restoreStackSize(stackSize); | ||
1754 | } | ||
1755 | |||
1756 | rule__GraphPattern__Alternatives | ||
1757 | @init { | ||
1758 | int stackSize = keepStackSize(); | ||
1759 | } | ||
1760 | : | ||
1761 | ( | ||
1762 | { before(grammarAccess.getGraphPatternAccess().getGraphPatternReferenceParserRuleCall_0()); } | ||
1763 | ruleGraphPatternReference | ||
1764 | { after(grammarAccess.getGraphPatternAccess().getGraphPatternReferenceParserRuleCall_0()); } | ||
1765 | ) | ||
1766 | | | ||
1767 | ( | ||
1768 | { before(grammarAccess.getGraphPatternAccess().getPatternSpecificationParserRuleCall_1()); } | ||
1769 | rulePatternSpecification | ||
1770 | { after(grammarAccess.getGraphPatternAccess().getPatternSpecificationParserRuleCall_1()); } | ||
1771 | ) | ||
1772 | ; | ||
1773 | finally { | ||
1774 | restoreStackSize(stackSize); | ||
1775 | } | ||
1776 | |||
1777 | rule__Config__Alternatives | ||
1778 | @init { | ||
1779 | int stackSize = keepStackSize(); | ||
1780 | } | ||
1781 | : | ||
1782 | ( | ||
1783 | { before(grammarAccess.getConfigAccess().getConfigSpecificationParserRuleCall_0()); } | ||
1784 | ruleConfigSpecification | ||
1785 | { after(grammarAccess.getConfigAccess().getConfigSpecificationParserRuleCall_0()); } | ||
1786 | ) | ||
1787 | | | ||
1788 | ( | ||
1789 | { before(grammarAccess.getConfigAccess().getConfigReferenceParserRuleCall_1()); } | ||
1790 | ruleConfigReference | ||
1791 | { after(grammarAccess.getConfigAccess().getConfigReferenceParserRuleCall_1()); } | ||
1792 | ) | ||
1793 | ; | ||
1794 | finally { | ||
1795 | restoreStackSize(stackSize); | ||
1796 | } | ||
1797 | |||
1798 | rule__TypeScope__Alternatives | ||
1799 | @init { | ||
1800 | int stackSize = keepStackSize(); | ||
1801 | } | ||
1802 | : | ||
1803 | ( | ||
1804 | { before(grammarAccess.getTypeScopeAccess().getClassTypeScopeParserRuleCall_0()); } | ||
1805 | ruleClassTypeScope | ||
1806 | { after(grammarAccess.getTypeScopeAccess().getClassTypeScopeParserRuleCall_0()); } | ||
1807 | ) | ||
1808 | | | ||
1809 | ( | ||
1810 | { before(grammarAccess.getTypeScopeAccess().getObjectTypeScopeParserRuleCall_1()); } | ||
1811 | ruleObjectTypeScope | ||
1812 | { after(grammarAccess.getTypeScopeAccess().getObjectTypeScopeParserRuleCall_1()); } | ||
1813 | ) | ||
1814 | | | ||
1815 | ( | ||
1816 | { before(grammarAccess.getTypeScopeAccess().getIntegerTypeScopeParserRuleCall_2()); } | ||
1817 | ruleIntegerTypeScope | ||
1818 | { after(grammarAccess.getTypeScopeAccess().getIntegerTypeScopeParserRuleCall_2()); } | ||
1819 | ) | ||
1820 | | | ||
1821 | ( | ||
1822 | { before(grammarAccess.getTypeScopeAccess().getRealTypeScopeParserRuleCall_3()); } | ||
1823 | ruleRealTypeScope | ||
1824 | { after(grammarAccess.getTypeScopeAccess().getRealTypeScopeParserRuleCall_3()); } | ||
1825 | ) | ||
1826 | | | ||
1827 | ( | ||
1828 | { before(grammarAccess.getTypeScopeAccess().getStringTypeScopeParserRuleCall_4()); } | ||
1829 | ruleStringTypeScope | ||
1830 | { after(grammarAccess.getTypeScopeAccess().getStringTypeScopeParserRuleCall_4()); } | ||
1831 | ) | ||
1832 | ; | ||
1833 | finally { | ||
1834 | restoreStackSize(stackSize); | ||
1835 | } | ||
1836 | |||
1837 | rule__ClassTypeScope__Alternatives_2 | ||
1838 | @init { | ||
1839 | int stackSize = keepStackSize(); | ||
1840 | } | ||
1841 | : | ||
1842 | ( | ||
1843 | { before(grammarAccess.getClassTypeScopeAccess().getSetsNewAssignment_2_0()); } | ||
1844 | (rule__ClassTypeScope__SetsNewAssignment_2_0) | ||
1845 | { after(grammarAccess.getClassTypeScopeAccess().getSetsNewAssignment_2_0()); } | ||
1846 | ) | ||
1847 | | | ||
1848 | ( | ||
1849 | { before(grammarAccess.getClassTypeScopeAccess().getSetsSumAssignment_2_1()); } | ||
1850 | (rule__ClassTypeScope__SetsSumAssignment_2_1) | ||
1851 | { after(grammarAccess.getClassTypeScopeAccess().getSetsSumAssignment_2_1()); } | ||
1852 | ) | ||
1853 | ; | ||
1854 | finally { | ||
1855 | restoreStackSize(stackSize); | ||
1856 | } | ||
1857 | |||
1858 | rule__ClassTypeScope__Alternatives_3 | ||
1859 | @init { | ||
1860 | int stackSize = keepStackSize(); | ||
1861 | } | ||
1862 | : | ||
1863 | ( | ||
1864 | { before(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_0()); } | ||
1865 | (rule__ClassTypeScope__NumberAssignment_3_0) | ||
1866 | { after(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_0()); } | ||
1867 | ) | ||
1868 | | | ||
1869 | ( | ||
1870 | { before(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_1()); } | ||
1871 | (rule__ClassTypeScope__NumberAssignment_3_1) | ||
1872 | { after(grammarAccess.getClassTypeScopeAccess().getNumberAssignment_3_1()); } | ||
1873 | ) | ||
1874 | ; | ||
1875 | finally { | ||
1876 | restoreStackSize(stackSize); | ||
1877 | } | ||
1878 | |||
1879 | rule__ObjectTypeScope__Alternatives_2 | ||
1880 | @init { | ||
1881 | int stackSize = keepStackSize(); | ||
1882 | } | ||
1883 | : | ||
1884 | ( | ||
1885 | { before(grammarAccess.getObjectTypeScopeAccess().getSetsNewAssignment_2_0()); } | ||
1886 | (rule__ObjectTypeScope__SetsNewAssignment_2_0) | ||
1887 | { after(grammarAccess.getObjectTypeScopeAccess().getSetsNewAssignment_2_0()); } | ||
1888 | ) | ||
1889 | | | ||
1890 | ( | ||
1891 | { before(grammarAccess.getObjectTypeScopeAccess().getSetsSumAssignment_2_1()); } | ||
1892 | (rule__ObjectTypeScope__SetsSumAssignment_2_1) | ||
1893 | { after(grammarAccess.getObjectTypeScopeAccess().getSetsSumAssignment_2_1()); } | ||
1894 | ) | ||
1895 | ; | ||
1896 | finally { | ||
1897 | restoreStackSize(stackSize); | ||
1898 | } | ||
1899 | |||
1900 | rule__ObjectTypeScope__Alternatives_3 | ||
1901 | @init { | ||
1902 | int stackSize = keepStackSize(); | ||
1903 | } | ||
1904 | : | ||
1905 | ( | ||
1906 | { before(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_0()); } | ||
1907 | (rule__ObjectTypeScope__NumberAssignment_3_0) | ||
1908 | { after(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_0()); } | ||
1909 | ) | ||
1910 | | | ||
1911 | ( | ||
1912 | { before(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_1()); } | ||
1913 | (rule__ObjectTypeScope__NumberAssignment_3_1) | ||
1914 | { after(grammarAccess.getObjectTypeScopeAccess().getNumberAssignment_3_1()); } | ||
1915 | ) | ||
1916 | ; | ||
1917 | finally { | ||
1918 | restoreStackSize(stackSize); | ||
1919 | } | ||
1920 | |||
1921 | rule__IntegerTypeScope__Alternatives_2 | ||
1922 | @init { | ||
1923 | int stackSize = keepStackSize(); | ||
1924 | } | ||
1925 | : | ||
1926 | ( | ||
1927 | { before(grammarAccess.getIntegerTypeScopeAccess().getSetsNewAssignment_2_0()); } | ||
1928 | (rule__IntegerTypeScope__SetsNewAssignment_2_0) | ||
1929 | { after(grammarAccess.getIntegerTypeScopeAccess().getSetsNewAssignment_2_0()); } | ||
1930 | ) | ||
1931 | | | ||
1932 | ( | ||
1933 | { before(grammarAccess.getIntegerTypeScopeAccess().getSetsSumAssignment_2_1()); } | ||
1934 | (rule__IntegerTypeScope__SetsSumAssignment_2_1) | ||
1935 | { after(grammarAccess.getIntegerTypeScopeAccess().getSetsSumAssignment_2_1()); } | ||
1936 | ) | ||
1937 | ; | ||
1938 | finally { | ||
1939 | restoreStackSize(stackSize); | ||
1940 | } | ||
1941 | |||
1942 | rule__IntegerTypeScope__Alternatives_3 | ||
1943 | @init { | ||
1944 | int stackSize = keepStackSize(); | ||
1945 | } | ||
1946 | : | ||
1947 | ( | ||
1948 | { before(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_0()); } | ||
1949 | (rule__IntegerTypeScope__NumberAssignment_3_0) | ||
1950 | { after(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_0()); } | ||
1951 | ) | ||
1952 | | | ||
1953 | ( | ||
1954 | { before(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_1()); } | ||
1955 | (rule__IntegerTypeScope__NumberAssignment_3_1) | ||
1956 | { after(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_1()); } | ||
1957 | ) | ||
1958 | | | ||
1959 | ( | ||
1960 | { before(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_2()); } | ||
1961 | (rule__IntegerTypeScope__NumberAssignment_3_2) | ||
1962 | { after(grammarAccess.getIntegerTypeScopeAccess().getNumberAssignment_3_2()); } | ||
1963 | ) | ||
1964 | ; | ||
1965 | finally { | ||
1966 | restoreStackSize(stackSize); | ||
1967 | } | ||
1968 | |||
1969 | rule__RealTypeScope__Alternatives_2 | ||
1970 | @init { | ||
1971 | int stackSize = keepStackSize(); | ||
1972 | } | ||
1973 | : | ||
1974 | ( | ||
1975 | { before(grammarAccess.getRealTypeScopeAccess().getSetsNewAssignment_2_0()); } | ||
1976 | (rule__RealTypeScope__SetsNewAssignment_2_0) | ||
1977 | { after(grammarAccess.getRealTypeScopeAccess().getSetsNewAssignment_2_0()); } | ||
1978 | ) | ||
1979 | | | ||
1980 | ( | ||
1981 | { before(grammarAccess.getRealTypeScopeAccess().getSetsSumAssignment_2_1()); } | ||
1982 | (rule__RealTypeScope__SetsSumAssignment_2_1) | ||
1983 | { after(grammarAccess.getRealTypeScopeAccess().getSetsSumAssignment_2_1()); } | ||
1984 | ) | ||
1985 | ; | ||
1986 | finally { | ||
1987 | restoreStackSize(stackSize); | ||
1988 | } | ||
1989 | |||
1990 | rule__RealTypeScope__Alternatives_3 | ||
1991 | @init { | ||
1992 | int stackSize = keepStackSize(); | ||
1993 | } | ||
1994 | : | ||
1995 | ( | ||
1996 | { before(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_0()); } | ||
1997 | (rule__RealTypeScope__NumberAssignment_3_0) | ||
1998 | { after(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_0()); } | ||
1999 | ) | ||
2000 | | | ||
2001 | ( | ||
2002 | { before(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_1()); } | ||
2003 | (rule__RealTypeScope__NumberAssignment_3_1) | ||
2004 | { after(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_1()); } | ||
2005 | ) | ||
2006 | | | ||
2007 | ( | ||
2008 | { before(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_2()); } | ||
2009 | (rule__RealTypeScope__NumberAssignment_3_2) | ||
2010 | { after(grammarAccess.getRealTypeScopeAccess().getNumberAssignment_3_2()); } | ||
2011 | ) | ||
2012 | ; | ||
2013 | finally { | ||
2014 | restoreStackSize(stackSize); | ||
2015 | } | ||
2016 | |||
2017 | rule__StringTypeScope__Alternatives_2 | ||
2018 | @init { | ||
2019 | int stackSize = keepStackSize(); | ||
2020 | } | ||
2021 | : | ||
2022 | ( | ||
2023 | { before(grammarAccess.getStringTypeScopeAccess().getSetsNewAssignment_2_0()); } | ||
2024 | (rule__StringTypeScope__SetsNewAssignment_2_0) | ||
2025 | { after(grammarAccess.getStringTypeScopeAccess().getSetsNewAssignment_2_0()); } | ||
2026 | ) | ||
2027 | | | ||
2028 | ( | ||
2029 | { before(grammarAccess.getStringTypeScopeAccess().getSetsSumAssignment_2_1()); } | ||
2030 | (rule__StringTypeScope__SetsSumAssignment_2_1) | ||
2031 | { after(grammarAccess.getStringTypeScopeAccess().getSetsSumAssignment_2_1()); } | ||
2032 | ) | ||
2033 | ; | ||
2034 | finally { | ||
2035 | restoreStackSize(stackSize); | ||
2036 | } | ||
2037 | |||
2038 | rule__StringTypeScope__Alternatives_3 | ||
2039 | @init { | ||
2040 | int stackSize = keepStackSize(); | ||
2041 | } | ||
2042 | : | ||
2043 | ( | ||
2044 | { before(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_0()); } | ||
2045 | (rule__StringTypeScope__NumberAssignment_3_0) | ||
2046 | { after(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_0()); } | ||
2047 | ) | ||
2048 | | | ||
2049 | ( | ||
2050 | { before(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_1()); } | ||
2051 | (rule__StringTypeScope__NumberAssignment_3_1) | ||
2052 | { after(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_1()); } | ||
2053 | ) | ||
2054 | | | ||
2055 | ( | ||
2056 | { before(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_2()); } | ||
2057 | (rule__StringTypeScope__NumberAssignment_3_2) | ||
2058 | { after(grammarAccess.getStringTypeScopeAccess().getNumberAssignment_3_2()); } | ||
2059 | ) | ||
2060 | ; | ||
2061 | finally { | ||
2062 | restoreStackSize(stackSize); | ||
2063 | } | ||
2064 | |||
2065 | rule__ExactNumber__Alternatives | ||
2066 | @init { | ||
2067 | int stackSize = keepStackSize(); | ||
2068 | } | ||
2069 | : | ||
2070 | ( | ||
2071 | { before(grammarAccess.getExactNumberAccess().getExactNumberAssignment_0()); } | ||
2072 | (rule__ExactNumber__ExactNumberAssignment_0) | ||
2073 | { after(grammarAccess.getExactNumberAccess().getExactNumberAssignment_0()); } | ||
2074 | ) | ||
2075 | | | ||
2076 | ( | ||
2077 | { before(grammarAccess.getExactNumberAccess().getExactUnlimitedAssignment_1()); } | ||
2078 | (rule__ExactNumber__ExactUnlimitedAssignment_1) | ||
2079 | { after(grammarAccess.getExactNumberAccess().getExactUnlimitedAssignment_1()); } | ||
2080 | ) | ||
2081 | ; | ||
2082 | finally { | ||
2083 | restoreStackSize(stackSize); | ||
2084 | } | ||
2085 | |||
2086 | rule__IntervallNumber__Alternatives_2 | ||
2087 | @init { | ||
2088 | int stackSize = keepStackSize(); | ||
2089 | } | ||
2090 | : | ||
2091 | ( | ||
2092 | { before(grammarAccess.getIntervallNumberAccess().getMaxNumberAssignment_2_0()); } | ||
2093 | (rule__IntervallNumber__MaxNumberAssignment_2_0) | ||
2094 | { after(grammarAccess.getIntervallNumberAccess().getMaxNumberAssignment_2_0()); } | ||
2095 | ) | ||
2096 | | | ||
2097 | ( | ||
2098 | { before(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAssignment_2_1()); } | ||
2099 | (rule__IntervallNumber__MaxUnlimitedAssignment_2_1) | ||
2100 | { after(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAssignment_2_1()); } | ||
2101 | ) | ||
2102 | ; | ||
2103 | finally { | ||
2104 | restoreStackSize(stackSize); | ||
2105 | } | ||
2106 | |||
2107 | rule__Scope__Alternatives | ||
2108 | @init { | ||
2109 | int stackSize = keepStackSize(); | ||
2110 | } | ||
2111 | : | ||
2112 | ( | ||
2113 | { before(grammarAccess.getScopeAccess().getScopeSpecificationParserRuleCall_0()); } | ||
2114 | ruleScopeSpecification | ||
2115 | { after(grammarAccess.getScopeAccess().getScopeSpecificationParserRuleCall_0()); } | ||
2116 | ) | ||
2117 | | | ||
2118 | ( | ||
2119 | { before(grammarAccess.getScopeAccess().getScopeReferenceParserRuleCall_1()); } | ||
2120 | ruleScopeReference | ||
2121 | { after(grammarAccess.getScopeAccess().getScopeReferenceParserRuleCall_1()); } | ||
2122 | ) | ||
2123 | ; | ||
2124 | finally { | ||
2125 | restoreStackSize(stackSize); | ||
2126 | } | ||
2127 | |||
2128 | rule__Solver__Alternatives | ||
2129 | @init { | ||
2130 | int stackSize = keepStackSize(); | ||
2131 | } | ||
2132 | : | ||
2133 | ( | ||
2134 | { before(grammarAccess.getSolverAccess().getSMTSolverEnumLiteralDeclaration_0()); } | ||
2135 | ('SMTSolver') | ||
2136 | { after(grammarAccess.getSolverAccess().getSMTSolverEnumLiteralDeclaration_0()); } | ||
2137 | ) | ||
2138 | | | ||
2139 | ( | ||
2140 | { before(grammarAccess.getSolverAccess().getAlloySolverEnumLiteralDeclaration_1()); } | ||
2141 | ('AlloySolver') | ||
2142 | { after(grammarAccess.getSolverAccess().getAlloySolverEnumLiteralDeclaration_1()); } | ||
2143 | ) | ||
2144 | | | ||
2145 | ( | ||
2146 | { before(grammarAccess.getSolverAccess().getViatraSolverEnumLiteralDeclaration_2()); } | ||
2147 | ('ViatraSolver') | ||
2148 | { after(grammarAccess.getSolverAccess().getViatraSolverEnumLiteralDeclaration_2()); } | ||
2149 | ) | ||
2150 | ; | ||
2151 | finally { | ||
2152 | restoreStackSize(stackSize); | ||
2153 | } | ||
2154 | |||
394 | rule__ConfigurationScript__Group__0 | 2155 | rule__ConfigurationScript__Group__0 |
395 | @init { | 2156 | @init { |
396 | int stackSize = keepStackSize(); | 2157 | int stackSize = keepStackSize(); |
@@ -445,6 +2206,114 @@ finally { | |||
445 | } | 2206 | } |
446 | 2207 | ||
447 | 2208 | ||
2209 | rule__QualifiedName__Group__0 | ||
2210 | @init { | ||
2211 | int stackSize = keepStackSize(); | ||
2212 | } | ||
2213 | : | ||
2214 | rule__QualifiedName__Group__0__Impl | ||
2215 | rule__QualifiedName__Group__1 | ||
2216 | ; | ||
2217 | finally { | ||
2218 | restoreStackSize(stackSize); | ||
2219 | } | ||
2220 | |||
2221 | rule__QualifiedName__Group__0__Impl | ||
2222 | @init { | ||
2223 | int stackSize = keepStackSize(); | ||
2224 | } | ||
2225 | : | ||
2226 | ( | ||
2227 | { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); } | ||
2228 | RULE_ID | ||
2229 | { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); } | ||
2230 | ) | ||
2231 | ; | ||
2232 | finally { | ||
2233 | restoreStackSize(stackSize); | ||
2234 | } | ||
2235 | |||
2236 | rule__QualifiedName__Group__1 | ||
2237 | @init { | ||
2238 | int stackSize = keepStackSize(); | ||
2239 | } | ||
2240 | : | ||
2241 | rule__QualifiedName__Group__1__Impl | ||
2242 | ; | ||
2243 | finally { | ||
2244 | restoreStackSize(stackSize); | ||
2245 | } | ||
2246 | |||
2247 | rule__QualifiedName__Group__1__Impl | ||
2248 | @init { | ||
2249 | int stackSize = keepStackSize(); | ||
2250 | } | ||
2251 | : | ||
2252 | ( | ||
2253 | { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); } | ||
2254 | (rule__QualifiedName__Group_1__0)* | ||
2255 | { after(grammarAccess.getQualifiedNameAccess().getGroup_1()); } | ||
2256 | ) | ||
2257 | ; | ||
2258 | finally { | ||
2259 | restoreStackSize(stackSize); | ||
2260 | } | ||
2261 | |||
2262 | |||
2263 | rule__QualifiedName__Group_1__0 | ||
2264 | @init { | ||
2265 | int stackSize = keepStackSize(); | ||
2266 | } | ||
2267 | : | ||
2268 | rule__QualifiedName__Group_1__0__Impl | ||
2269 | rule__QualifiedName__Group_1__1 | ||
2270 | ; | ||
2271 | finally { | ||
2272 | restoreStackSize(stackSize); | ||
2273 | } | ||
2274 | |||
2275 | rule__QualifiedName__Group_1__0__Impl | ||
2276 | @init { | ||
2277 | int stackSize = keepStackSize(); | ||
2278 | } | ||
2279 | : | ||
2280 | ( | ||
2281 | { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); } | ||
2282 | '.' | ||
2283 | { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); } | ||
2284 | ) | ||
2285 | ; | ||
2286 | finally { | ||
2287 | restoreStackSize(stackSize); | ||
2288 | } | ||
2289 | |||
2290 | rule__QualifiedName__Group_1__1 | ||
2291 | @init { | ||
2292 | int stackSize = keepStackSize(); | ||
2293 | } | ||
2294 | : | ||
2295 | rule__QualifiedName__Group_1__1__Impl | ||
2296 | ; | ||
2297 | finally { | ||
2298 | restoreStackSize(stackSize); | ||
2299 | } | ||
2300 | |||
2301 | rule__QualifiedName__Group_1__1__Impl | ||
2302 | @init { | ||
2303 | int stackSize = keepStackSize(); | ||
2304 | } | ||
2305 | : | ||
2306 | ( | ||
2307 | { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); } | ||
2308 | RULE_ID | ||
2309 | { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); } | ||
2310 | ) | ||
2311 | ; | ||
2312 | finally { | ||
2313 | restoreStackSize(stackSize); | ||
2314 | } | ||
2315 | |||
2316 | |||
448 | rule__EPackageImport__Group__0 | 2317 | rule__EPackageImport__Group__0 |
449 | @init { | 2318 | @init { |
450 | int stackSize = keepStackSize(); | 2319 | int stackSize = keepStackSize(); |
@@ -607,6 +2476,114 @@ finally { | |||
607 | } | 2476 | } |
608 | 2477 | ||
609 | 2478 | ||
2479 | rule__FileDeclaration__Group__0 | ||
2480 | @init { | ||
2481 | int stackSize = keepStackSize(); | ||
2482 | } | ||
2483 | : | ||
2484 | rule__FileDeclaration__Group__0__Impl | ||
2485 | rule__FileDeclaration__Group__1 | ||
2486 | ; | ||
2487 | finally { | ||
2488 | restoreStackSize(stackSize); | ||
2489 | } | ||
2490 | |||
2491 | rule__FileDeclaration__Group__0__Impl | ||
2492 | @init { | ||
2493 | int stackSize = keepStackSize(); | ||
2494 | } | ||
2495 | : | ||
2496 | ( | ||
2497 | { before(grammarAccess.getFileDeclarationAccess().getFileKeyword_0()); } | ||
2498 | 'file' | ||
2499 | { after(grammarAccess.getFileDeclarationAccess().getFileKeyword_0()); } | ||
2500 | ) | ||
2501 | ; | ||
2502 | finally { | ||
2503 | restoreStackSize(stackSize); | ||
2504 | } | ||
2505 | |||
2506 | rule__FileDeclaration__Group__1 | ||
2507 | @init { | ||
2508 | int stackSize = keepStackSize(); | ||
2509 | } | ||
2510 | : | ||
2511 | rule__FileDeclaration__Group__1__Impl | ||
2512 | rule__FileDeclaration__Group__2 | ||
2513 | ; | ||
2514 | finally { | ||
2515 | restoreStackSize(stackSize); | ||
2516 | } | ||
2517 | |||
2518 | rule__FileDeclaration__Group__1__Impl | ||
2519 | @init { | ||
2520 | int stackSize = keepStackSize(); | ||
2521 | } | ||
2522 | : | ||
2523 | ( | ||
2524 | { before(grammarAccess.getFileDeclarationAccess().getNameAssignment_1()); } | ||
2525 | (rule__FileDeclaration__NameAssignment_1) | ||
2526 | { after(grammarAccess.getFileDeclarationAccess().getNameAssignment_1()); } | ||
2527 | ) | ||
2528 | ; | ||
2529 | finally { | ||
2530 | restoreStackSize(stackSize); | ||
2531 | } | ||
2532 | |||
2533 | rule__FileDeclaration__Group__2 | ||
2534 | @init { | ||
2535 | int stackSize = keepStackSize(); | ||
2536 | } | ||
2537 | : | ||
2538 | rule__FileDeclaration__Group__2__Impl | ||
2539 | rule__FileDeclaration__Group__3 | ||
2540 | ; | ||
2541 | finally { | ||
2542 | restoreStackSize(stackSize); | ||
2543 | } | ||
2544 | |||
2545 | rule__FileDeclaration__Group__2__Impl | ||
2546 | @init { | ||
2547 | int stackSize = keepStackSize(); | ||
2548 | } | ||
2549 | : | ||
2550 | ( | ||
2551 | { before(grammarAccess.getFileDeclarationAccess().getEqualsSignKeyword_2()); } | ||
2552 | '=' | ||
2553 | { after(grammarAccess.getFileDeclarationAccess().getEqualsSignKeyword_2()); } | ||
2554 | ) | ||
2555 | ; | ||
2556 | finally { | ||
2557 | restoreStackSize(stackSize); | ||
2558 | } | ||
2559 | |||
2560 | rule__FileDeclaration__Group__3 | ||
2561 | @init { | ||
2562 | int stackSize = keepStackSize(); | ||
2563 | } | ||
2564 | : | ||
2565 | rule__FileDeclaration__Group__3__Impl | ||
2566 | ; | ||
2567 | finally { | ||
2568 | restoreStackSize(stackSize); | ||
2569 | } | ||
2570 | |||
2571 | rule__FileDeclaration__Group__3__Impl | ||
2572 | @init { | ||
2573 | int stackSize = keepStackSize(); | ||
2574 | } | ||
2575 | : | ||
2576 | ( | ||
2577 | { before(grammarAccess.getFileDeclarationAccess().getSpecificationAssignment_3()); } | ||
2578 | (rule__FileDeclaration__SpecificationAssignment_3) | ||
2579 | { after(grammarAccess.getFileDeclarationAccess().getSpecificationAssignment_3()); } | ||
2580 | ) | ||
2581 | ; | ||
2582 | finally { | ||
2583 | restoreStackSize(stackSize); | ||
2584 | } | ||
2585 | |||
2586 | |||
610 | rule__MetamodelSpecification__Group__0 | 2587 | rule__MetamodelSpecification__Group__0 |
611 | @init { | 2588 | @init { |
612 | int stackSize = keepStackSize(); | 2589 | int stackSize = keepStackSize(); |
@@ -1309,6 +3286,4841 @@ finally { | |||
1309 | } | 3286 | } |
1310 | 3287 | ||
1311 | 3288 | ||
3289 | rule__PartialModelSpecification__Group__0 | ||
3290 | @init { | ||
3291 | int stackSize = keepStackSize(); | ||
3292 | } | ||
3293 | : | ||
3294 | rule__PartialModelSpecification__Group__0__Impl | ||
3295 | rule__PartialModelSpecification__Group__1 | ||
3296 | ; | ||
3297 | finally { | ||
3298 | restoreStackSize(stackSize); | ||
3299 | } | ||
3300 | |||
3301 | rule__PartialModelSpecification__Group__0__Impl | ||
3302 | @init { | ||
3303 | int stackSize = keepStackSize(); | ||
3304 | } | ||
3305 | : | ||
3306 | ( | ||
3307 | { before(grammarAccess.getPartialModelSpecificationAccess().getLeftCurlyBracketKeyword_0()); } | ||
3308 | '{' | ||
3309 | { after(grammarAccess.getPartialModelSpecificationAccess().getLeftCurlyBracketKeyword_0()); } | ||
3310 | ) | ||
3311 | ; | ||
3312 | finally { | ||
3313 | restoreStackSize(stackSize); | ||
3314 | } | ||
3315 | |||
3316 | rule__PartialModelSpecification__Group__1 | ||
3317 | @init { | ||
3318 | int stackSize = keepStackSize(); | ||
3319 | } | ||
3320 | : | ||
3321 | rule__PartialModelSpecification__Group__1__Impl | ||
3322 | rule__PartialModelSpecification__Group__2 | ||
3323 | ; | ||
3324 | finally { | ||
3325 | restoreStackSize(stackSize); | ||
3326 | } | ||
3327 | |||
3328 | rule__PartialModelSpecification__Group__1__Impl | ||
3329 | @init { | ||
3330 | int stackSize = keepStackSize(); | ||
3331 | } | ||
3332 | : | ||
3333 | ( | ||
3334 | { before(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_1()); } | ||
3335 | (rule__PartialModelSpecification__EntryAssignment_1) | ||
3336 | { after(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_1()); } | ||
3337 | ) | ||
3338 | ; | ||
3339 | finally { | ||
3340 | restoreStackSize(stackSize); | ||
3341 | } | ||
3342 | |||
3343 | rule__PartialModelSpecification__Group__2 | ||
3344 | @init { | ||
3345 | int stackSize = keepStackSize(); | ||
3346 | } | ||
3347 | : | ||
3348 | rule__PartialModelSpecification__Group__2__Impl | ||
3349 | rule__PartialModelSpecification__Group__3 | ||
3350 | ; | ||
3351 | finally { | ||
3352 | restoreStackSize(stackSize); | ||
3353 | } | ||
3354 | |||
3355 | rule__PartialModelSpecification__Group__2__Impl | ||
3356 | @init { | ||
3357 | int stackSize = keepStackSize(); | ||
3358 | } | ||
3359 | : | ||
3360 | ( | ||
3361 | { before(grammarAccess.getPartialModelSpecificationAccess().getGroup_2()); } | ||
3362 | (rule__PartialModelSpecification__Group_2__0)? | ||
3363 | { after(grammarAccess.getPartialModelSpecificationAccess().getGroup_2()); } | ||
3364 | ) | ||
3365 | ; | ||
3366 | finally { | ||
3367 | restoreStackSize(stackSize); | ||
3368 | } | ||
3369 | |||
3370 | rule__PartialModelSpecification__Group__3 | ||
3371 | @init { | ||
3372 | int stackSize = keepStackSize(); | ||
3373 | } | ||
3374 | : | ||
3375 | rule__PartialModelSpecification__Group__3__Impl | ||
3376 | ; | ||
3377 | finally { | ||
3378 | restoreStackSize(stackSize); | ||
3379 | } | ||
3380 | |||
3381 | rule__PartialModelSpecification__Group__3__Impl | ||
3382 | @init { | ||
3383 | int stackSize = keepStackSize(); | ||
3384 | } | ||
3385 | : | ||
3386 | ( | ||
3387 | { before(grammarAccess.getPartialModelSpecificationAccess().getRightCurlyBracketKeyword_3()); } | ||
3388 | '}' | ||
3389 | { after(grammarAccess.getPartialModelSpecificationAccess().getRightCurlyBracketKeyword_3()); } | ||
3390 | ) | ||
3391 | ; | ||
3392 | finally { | ||
3393 | restoreStackSize(stackSize); | ||
3394 | } | ||
3395 | |||
3396 | |||
3397 | rule__PartialModelSpecification__Group_2__0 | ||
3398 | @init { | ||
3399 | int stackSize = keepStackSize(); | ||
3400 | } | ||
3401 | : | ||
3402 | rule__PartialModelSpecification__Group_2__0__Impl | ||
3403 | rule__PartialModelSpecification__Group_2__1 | ||
3404 | ; | ||
3405 | finally { | ||
3406 | restoreStackSize(stackSize); | ||
3407 | } | ||
3408 | |||
3409 | rule__PartialModelSpecification__Group_2__0__Impl | ||
3410 | @init { | ||
3411 | int stackSize = keepStackSize(); | ||
3412 | } | ||
3413 | : | ||
3414 | ( | ||
3415 | { before(grammarAccess.getPartialModelSpecificationAccess().getCommaKeyword_2_0()); } | ||
3416 | ',' | ||
3417 | { after(grammarAccess.getPartialModelSpecificationAccess().getCommaKeyword_2_0()); } | ||
3418 | ) | ||
3419 | ; | ||
3420 | finally { | ||
3421 | restoreStackSize(stackSize); | ||
3422 | } | ||
3423 | |||
3424 | rule__PartialModelSpecification__Group_2__1 | ||
3425 | @init { | ||
3426 | int stackSize = keepStackSize(); | ||
3427 | } | ||
3428 | : | ||
3429 | rule__PartialModelSpecification__Group_2__1__Impl | ||
3430 | ; | ||
3431 | finally { | ||
3432 | restoreStackSize(stackSize); | ||
3433 | } | ||
3434 | |||
3435 | rule__PartialModelSpecification__Group_2__1__Impl | ||
3436 | @init { | ||
3437 | int stackSize = keepStackSize(); | ||
3438 | } | ||
3439 | : | ||
3440 | ( | ||
3441 | { before(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_2_1()); } | ||
3442 | (rule__PartialModelSpecification__EntryAssignment_2_1) | ||
3443 | { after(grammarAccess.getPartialModelSpecificationAccess().getEntryAssignment_2_1()); } | ||
3444 | ) | ||
3445 | ; | ||
3446 | finally { | ||
3447 | restoreStackSize(stackSize); | ||
3448 | } | ||
3449 | |||
3450 | |||
3451 | rule__FolderEntry__Group__0 | ||
3452 | @init { | ||
3453 | int stackSize = keepStackSize(); | ||
3454 | } | ||
3455 | : | ||
3456 | rule__FolderEntry__Group__0__Impl | ||
3457 | rule__FolderEntry__Group__1 | ||
3458 | ; | ||
3459 | finally { | ||
3460 | restoreStackSize(stackSize); | ||
3461 | } | ||
3462 | |||
3463 | rule__FolderEntry__Group__0__Impl | ||
3464 | @init { | ||
3465 | int stackSize = keepStackSize(); | ||
3466 | } | ||
3467 | : | ||
3468 | ( | ||
3469 | { before(grammarAccess.getFolderEntryAccess().getFolderKeyword_0()); } | ||
3470 | 'folder' | ||
3471 | { after(grammarAccess.getFolderEntryAccess().getFolderKeyword_0()); } | ||
3472 | ) | ||
3473 | ; | ||
3474 | finally { | ||
3475 | restoreStackSize(stackSize); | ||
3476 | } | ||
3477 | |||
3478 | rule__FolderEntry__Group__1 | ||
3479 | @init { | ||
3480 | int stackSize = keepStackSize(); | ||
3481 | } | ||
3482 | : | ||
3483 | rule__FolderEntry__Group__1__Impl | ||
3484 | rule__FolderEntry__Group__2 | ||
3485 | ; | ||
3486 | finally { | ||
3487 | restoreStackSize(stackSize); | ||
3488 | } | ||
3489 | |||
3490 | rule__FolderEntry__Group__1__Impl | ||
3491 | @init { | ||
3492 | int stackSize = keepStackSize(); | ||
3493 | } | ||
3494 | : | ||
3495 | ( | ||
3496 | { before(grammarAccess.getFolderEntryAccess().getPathAssignment_1()); } | ||
3497 | (rule__FolderEntry__PathAssignment_1) | ||
3498 | { after(grammarAccess.getFolderEntryAccess().getPathAssignment_1()); } | ||
3499 | ) | ||
3500 | ; | ||
3501 | finally { | ||
3502 | restoreStackSize(stackSize); | ||
3503 | } | ||
3504 | |||
3505 | rule__FolderEntry__Group__2 | ||
3506 | @init { | ||
3507 | int stackSize = keepStackSize(); | ||
3508 | } | ||
3509 | : | ||
3510 | rule__FolderEntry__Group__2__Impl | ||
3511 | ; | ||
3512 | finally { | ||
3513 | restoreStackSize(stackSize); | ||
3514 | } | ||
3515 | |||
3516 | rule__FolderEntry__Group__2__Impl | ||
3517 | @init { | ||
3518 | int stackSize = keepStackSize(); | ||
3519 | } | ||
3520 | : | ||
3521 | ( | ||
3522 | { before(grammarAccess.getFolderEntryAccess().getGroup_2()); } | ||
3523 | (rule__FolderEntry__Group_2__0)? | ||
3524 | { after(grammarAccess.getFolderEntryAccess().getGroup_2()); } | ||
3525 | ) | ||
3526 | ; | ||
3527 | finally { | ||
3528 | restoreStackSize(stackSize); | ||
3529 | } | ||
3530 | |||
3531 | |||
3532 | rule__FolderEntry__Group_2__0 | ||
3533 | @init { | ||
3534 | int stackSize = keepStackSize(); | ||
3535 | } | ||
3536 | : | ||
3537 | rule__FolderEntry__Group_2__0__Impl | ||
3538 | rule__FolderEntry__Group_2__1 | ||
3539 | ; | ||
3540 | finally { | ||
3541 | restoreStackSize(stackSize); | ||
3542 | } | ||
3543 | |||
3544 | rule__FolderEntry__Group_2__0__Impl | ||
3545 | @init { | ||
3546 | int stackSize = keepStackSize(); | ||
3547 | } | ||
3548 | : | ||
3549 | ( | ||
3550 | { before(grammarAccess.getFolderEntryAccess().getExcludingKeyword_2_0()); } | ||
3551 | 'excluding' | ||
3552 | { after(grammarAccess.getFolderEntryAccess().getExcludingKeyword_2_0()); } | ||
3553 | ) | ||
3554 | ; | ||
3555 | finally { | ||
3556 | restoreStackSize(stackSize); | ||
3557 | } | ||
3558 | |||
3559 | rule__FolderEntry__Group_2__1 | ||
3560 | @init { | ||
3561 | int stackSize = keepStackSize(); | ||
3562 | } | ||
3563 | : | ||
3564 | rule__FolderEntry__Group_2__1__Impl | ||
3565 | rule__FolderEntry__Group_2__2 | ||
3566 | ; | ||
3567 | finally { | ||
3568 | restoreStackSize(stackSize); | ||
3569 | } | ||
3570 | |||
3571 | rule__FolderEntry__Group_2__1__Impl | ||
3572 | @init { | ||
3573 | int stackSize = keepStackSize(); | ||
3574 | } | ||
3575 | : | ||
3576 | ( | ||
3577 | { before(grammarAccess.getFolderEntryAccess().getLeftCurlyBracketKeyword_2_1()); } | ||
3578 | '{' | ||
3579 | { after(grammarAccess.getFolderEntryAccess().getLeftCurlyBracketKeyword_2_1()); } | ||
3580 | ) | ||
3581 | ; | ||
3582 | finally { | ||
3583 | restoreStackSize(stackSize); | ||
3584 | } | ||
3585 | |||
3586 | rule__FolderEntry__Group_2__2 | ||
3587 | @init { | ||
3588 | int stackSize = keepStackSize(); | ||
3589 | } | ||
3590 | : | ||
3591 | rule__FolderEntry__Group_2__2__Impl | ||
3592 | rule__FolderEntry__Group_2__3 | ||
3593 | ; | ||
3594 | finally { | ||
3595 | restoreStackSize(stackSize); | ||
3596 | } | ||
3597 | |||
3598 | rule__FolderEntry__Group_2__2__Impl | ||
3599 | @init { | ||
3600 | int stackSize = keepStackSize(); | ||
3601 | } | ||
3602 | : | ||
3603 | ( | ||
3604 | { before(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_2()); } | ||
3605 | (rule__FolderEntry__ExclusionAssignment_2_2) | ||
3606 | { after(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_2()); } | ||
3607 | ) | ||
3608 | ; | ||
3609 | finally { | ||
3610 | restoreStackSize(stackSize); | ||
3611 | } | ||
3612 | |||
3613 | rule__FolderEntry__Group_2__3 | ||
3614 | @init { | ||
3615 | int stackSize = keepStackSize(); | ||
3616 | } | ||
3617 | : | ||
3618 | rule__FolderEntry__Group_2__3__Impl | ||
3619 | rule__FolderEntry__Group_2__4 | ||
3620 | ; | ||
3621 | finally { | ||
3622 | restoreStackSize(stackSize); | ||
3623 | } | ||
3624 | |||
3625 | rule__FolderEntry__Group_2__3__Impl | ||
3626 | @init { | ||
3627 | int stackSize = keepStackSize(); | ||
3628 | } | ||
3629 | : | ||
3630 | ( | ||
3631 | { before(grammarAccess.getFolderEntryAccess().getGroup_2_3()); } | ||
3632 | (rule__FolderEntry__Group_2_3__0)* | ||
3633 | { after(grammarAccess.getFolderEntryAccess().getGroup_2_3()); } | ||
3634 | ) | ||
3635 | ; | ||
3636 | finally { | ||
3637 | restoreStackSize(stackSize); | ||
3638 | } | ||
3639 | |||
3640 | rule__FolderEntry__Group_2__4 | ||
3641 | @init { | ||
3642 | int stackSize = keepStackSize(); | ||
3643 | } | ||
3644 | : | ||
3645 | rule__FolderEntry__Group_2__4__Impl | ||
3646 | ; | ||
3647 | finally { | ||
3648 | restoreStackSize(stackSize); | ||
3649 | } | ||
3650 | |||
3651 | rule__FolderEntry__Group_2__4__Impl | ||
3652 | @init { | ||
3653 | int stackSize = keepStackSize(); | ||
3654 | } | ||
3655 | : | ||
3656 | ( | ||
3657 | { before(grammarAccess.getFolderEntryAccess().getRightCurlyBracketKeyword_2_4()); } | ||
3658 | '}' | ||
3659 | { after(grammarAccess.getFolderEntryAccess().getRightCurlyBracketKeyword_2_4()); } | ||
3660 | ) | ||
3661 | ; | ||
3662 | finally { | ||
3663 | restoreStackSize(stackSize); | ||
3664 | } | ||
3665 | |||
3666 | |||
3667 | rule__FolderEntry__Group_2_3__0 | ||
3668 | @init { | ||
3669 | int stackSize = keepStackSize(); | ||
3670 | } | ||
3671 | : | ||
3672 | rule__FolderEntry__Group_2_3__0__Impl | ||
3673 | rule__FolderEntry__Group_2_3__1 | ||
3674 | ; | ||
3675 | finally { | ||
3676 | restoreStackSize(stackSize); | ||
3677 | } | ||
3678 | |||
3679 | rule__FolderEntry__Group_2_3__0__Impl | ||
3680 | @init { | ||
3681 | int stackSize = keepStackSize(); | ||
3682 | } | ||
3683 | : | ||
3684 | ( | ||
3685 | { before(grammarAccess.getFolderEntryAccess().getCommaKeyword_2_3_0()); } | ||
3686 | ',' | ||
3687 | { after(grammarAccess.getFolderEntryAccess().getCommaKeyword_2_3_0()); } | ||
3688 | ) | ||
3689 | ; | ||
3690 | finally { | ||
3691 | restoreStackSize(stackSize); | ||
3692 | } | ||
3693 | |||
3694 | rule__FolderEntry__Group_2_3__1 | ||
3695 | @init { | ||
3696 | int stackSize = keepStackSize(); | ||
3697 | } | ||
3698 | : | ||
3699 | rule__FolderEntry__Group_2_3__1__Impl | ||
3700 | ; | ||
3701 | finally { | ||
3702 | restoreStackSize(stackSize); | ||
3703 | } | ||
3704 | |||
3705 | rule__FolderEntry__Group_2_3__1__Impl | ||
3706 | @init { | ||
3707 | int stackSize = keepStackSize(); | ||
3708 | } | ||
3709 | : | ||
3710 | ( | ||
3711 | { before(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_3_1()); } | ||
3712 | (rule__FolderEntry__ExclusionAssignment_2_3_1) | ||
3713 | { after(grammarAccess.getFolderEntryAccess().getExclusionAssignment_2_3_1()); } | ||
3714 | ) | ||
3715 | ; | ||
3716 | finally { | ||
3717 | restoreStackSize(stackSize); | ||
3718 | } | ||
3719 | |||
3720 | |||
3721 | rule__PartialModelDeclaration__Group__0 | ||
3722 | @init { | ||
3723 | int stackSize = keepStackSize(); | ||
3724 | } | ||
3725 | : | ||
3726 | rule__PartialModelDeclaration__Group__0__Impl | ||
3727 | rule__PartialModelDeclaration__Group__1 | ||
3728 | ; | ||
3729 | finally { | ||
3730 | restoreStackSize(stackSize); | ||
3731 | } | ||
3732 | |||
3733 | rule__PartialModelDeclaration__Group__0__Impl | ||
3734 | @init { | ||
3735 | int stackSize = keepStackSize(); | ||
3736 | } | ||
3737 | : | ||
3738 | ( | ||
3739 | { before(grammarAccess.getPartialModelDeclarationAccess().getModelsKeyword_0()); } | ||
3740 | 'models' | ||
3741 | { after(grammarAccess.getPartialModelDeclarationAccess().getModelsKeyword_0()); } | ||
3742 | ) | ||
3743 | ; | ||
3744 | finally { | ||
3745 | restoreStackSize(stackSize); | ||
3746 | } | ||
3747 | |||
3748 | rule__PartialModelDeclaration__Group__1 | ||
3749 | @init { | ||
3750 | int stackSize = keepStackSize(); | ||
3751 | } | ||
3752 | : | ||
3753 | rule__PartialModelDeclaration__Group__1__Impl | ||
3754 | rule__PartialModelDeclaration__Group__2 | ||
3755 | ; | ||
3756 | finally { | ||
3757 | restoreStackSize(stackSize); | ||
3758 | } | ||
3759 | |||
3760 | rule__PartialModelDeclaration__Group__1__Impl | ||
3761 | @init { | ||
3762 | int stackSize = keepStackSize(); | ||
3763 | } | ||
3764 | : | ||
3765 | ( | ||
3766 | { before(grammarAccess.getPartialModelDeclarationAccess().getNameAssignment_1()); } | ||
3767 | (rule__PartialModelDeclaration__NameAssignment_1) | ||
3768 | { after(grammarAccess.getPartialModelDeclarationAccess().getNameAssignment_1()); } | ||
3769 | ) | ||
3770 | ; | ||
3771 | finally { | ||
3772 | restoreStackSize(stackSize); | ||
3773 | } | ||
3774 | |||
3775 | rule__PartialModelDeclaration__Group__2 | ||
3776 | @init { | ||
3777 | int stackSize = keepStackSize(); | ||
3778 | } | ||
3779 | : | ||
3780 | rule__PartialModelDeclaration__Group__2__Impl | ||
3781 | ; | ||
3782 | finally { | ||
3783 | restoreStackSize(stackSize); | ||
3784 | } | ||
3785 | |||
3786 | rule__PartialModelDeclaration__Group__2__Impl | ||
3787 | @init { | ||
3788 | int stackSize = keepStackSize(); | ||
3789 | } | ||
3790 | : | ||
3791 | ( | ||
3792 | { before(grammarAccess.getPartialModelDeclarationAccess().getSpecificationAssignment_2()); } | ||
3793 | (rule__PartialModelDeclaration__SpecificationAssignment_2) | ||
3794 | { after(grammarAccess.getPartialModelDeclarationAccess().getSpecificationAssignment_2()); } | ||
3795 | ) | ||
3796 | ; | ||
3797 | finally { | ||
3798 | restoreStackSize(stackSize); | ||
3799 | } | ||
3800 | |||
3801 | |||
3802 | rule__PatternSpecification__Group__0 | ||
3803 | @init { | ||
3804 | int stackSize = keepStackSize(); | ||
3805 | } | ||
3806 | : | ||
3807 | rule__PatternSpecification__Group__0__Impl | ||
3808 | rule__PatternSpecification__Group__1 | ||
3809 | ; | ||
3810 | finally { | ||
3811 | restoreStackSize(stackSize); | ||
3812 | } | ||
3813 | |||
3814 | rule__PatternSpecification__Group__0__Impl | ||
3815 | @init { | ||
3816 | int stackSize = keepStackSize(); | ||
3817 | } | ||
3818 | : | ||
3819 | ( | ||
3820 | { before(grammarAccess.getPatternSpecificationAccess().getLeftCurlyBracketKeyword_0()); } | ||
3821 | '{' | ||
3822 | { after(grammarAccess.getPatternSpecificationAccess().getLeftCurlyBracketKeyword_0()); } | ||
3823 | ) | ||
3824 | ; | ||
3825 | finally { | ||
3826 | restoreStackSize(stackSize); | ||
3827 | } | ||
3828 | |||
3829 | rule__PatternSpecification__Group__1 | ||
3830 | @init { | ||
3831 | int stackSize = keepStackSize(); | ||
3832 | } | ||
3833 | : | ||
3834 | rule__PatternSpecification__Group__1__Impl | ||
3835 | rule__PatternSpecification__Group__2 | ||
3836 | ; | ||
3837 | finally { | ||
3838 | restoreStackSize(stackSize); | ||
3839 | } | ||
3840 | |||
3841 | rule__PatternSpecification__Group__1__Impl | ||
3842 | @init { | ||
3843 | int stackSize = keepStackSize(); | ||
3844 | } | ||
3845 | : | ||
3846 | ( | ||
3847 | { before(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_1()); } | ||
3848 | (rule__PatternSpecification__EntriesAssignment_1) | ||
3849 | { after(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_1()); } | ||
3850 | ) | ||
3851 | ; | ||
3852 | finally { | ||
3853 | restoreStackSize(stackSize); | ||
3854 | } | ||
3855 | |||
3856 | rule__PatternSpecification__Group__2 | ||
3857 | @init { | ||
3858 | int stackSize = keepStackSize(); | ||
3859 | } | ||
3860 | : | ||
3861 | rule__PatternSpecification__Group__2__Impl | ||
3862 | rule__PatternSpecification__Group__3 | ||
3863 | ; | ||
3864 | finally { | ||
3865 | restoreStackSize(stackSize); | ||
3866 | } | ||
3867 | |||
3868 | rule__PatternSpecification__Group__2__Impl | ||
3869 | @init { | ||
3870 | int stackSize = keepStackSize(); | ||
3871 | } | ||
3872 | : | ||
3873 | ( | ||
3874 | { before(grammarAccess.getPatternSpecificationAccess().getGroup_2()); } | ||
3875 | (rule__PatternSpecification__Group_2__0)* | ||
3876 | { after(grammarAccess.getPatternSpecificationAccess().getGroup_2()); } | ||
3877 | ) | ||
3878 | ; | ||
3879 | finally { | ||
3880 | restoreStackSize(stackSize); | ||
3881 | } | ||
3882 | |||
3883 | rule__PatternSpecification__Group__3 | ||
3884 | @init { | ||
3885 | int stackSize = keepStackSize(); | ||
3886 | } | ||
3887 | : | ||
3888 | rule__PatternSpecification__Group__3__Impl | ||
3889 | ; | ||
3890 | finally { | ||
3891 | restoreStackSize(stackSize); | ||
3892 | } | ||
3893 | |||
3894 | rule__PatternSpecification__Group__3__Impl | ||
3895 | @init { | ||
3896 | int stackSize = keepStackSize(); | ||
3897 | } | ||
3898 | : | ||
3899 | ( | ||
3900 | { before(grammarAccess.getPatternSpecificationAccess().getRightCurlyBracketKeyword_3()); } | ||
3901 | '}' | ||
3902 | { after(grammarAccess.getPatternSpecificationAccess().getRightCurlyBracketKeyword_3()); } | ||
3903 | ) | ||
3904 | ; | ||
3905 | finally { | ||
3906 | restoreStackSize(stackSize); | ||
3907 | } | ||
3908 | |||
3909 | |||
3910 | rule__PatternSpecification__Group_2__0 | ||
3911 | @init { | ||
3912 | int stackSize = keepStackSize(); | ||
3913 | } | ||
3914 | : | ||
3915 | rule__PatternSpecification__Group_2__0__Impl | ||
3916 | rule__PatternSpecification__Group_2__1 | ||
3917 | ; | ||
3918 | finally { | ||
3919 | restoreStackSize(stackSize); | ||
3920 | } | ||
3921 | |||
3922 | rule__PatternSpecification__Group_2__0__Impl | ||
3923 | @init { | ||
3924 | int stackSize = keepStackSize(); | ||
3925 | } | ||
3926 | : | ||
3927 | ( | ||
3928 | { before(grammarAccess.getPatternSpecificationAccess().getCommaKeyword_2_0()); } | ||
3929 | ',' | ||
3930 | { after(grammarAccess.getPatternSpecificationAccess().getCommaKeyword_2_0()); } | ||
3931 | ) | ||
3932 | ; | ||
3933 | finally { | ||
3934 | restoreStackSize(stackSize); | ||
3935 | } | ||
3936 | |||
3937 | rule__PatternSpecification__Group_2__1 | ||
3938 | @init { | ||
3939 | int stackSize = keepStackSize(); | ||
3940 | } | ||
3941 | : | ||
3942 | rule__PatternSpecification__Group_2__1__Impl | ||
3943 | ; | ||
3944 | finally { | ||
3945 | restoreStackSize(stackSize); | ||
3946 | } | ||
3947 | |||
3948 | rule__PatternSpecification__Group_2__1__Impl | ||
3949 | @init { | ||
3950 | int stackSize = keepStackSize(); | ||
3951 | } | ||
3952 | : | ||
3953 | ( | ||
3954 | { before(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_2_1()); } | ||
3955 | (rule__PatternSpecification__EntriesAssignment_2_1) | ||
3956 | { after(grammarAccess.getPatternSpecificationAccess().getEntriesAssignment_2_1()); } | ||
3957 | ) | ||
3958 | ; | ||
3959 | finally { | ||
3960 | restoreStackSize(stackSize); | ||
3961 | } | ||
3962 | |||
3963 | |||
3964 | rule__AllPatternEntry__Group__0 | ||
3965 | @init { | ||
3966 | int stackSize = keepStackSize(); | ||
3967 | } | ||
3968 | : | ||
3969 | rule__AllPatternEntry__Group__0__Impl | ||
3970 | rule__AllPatternEntry__Group__1 | ||
3971 | ; | ||
3972 | finally { | ||
3973 | restoreStackSize(stackSize); | ||
3974 | } | ||
3975 | |||
3976 | rule__AllPatternEntry__Group__0__Impl | ||
3977 | @init { | ||
3978 | int stackSize = keepStackSize(); | ||
3979 | } | ||
3980 | : | ||
3981 | ( | ||
3982 | { before(grammarAccess.getAllPatternEntryAccess().getPackageKeyword_0()); } | ||
3983 | 'package' | ||
3984 | { after(grammarAccess.getAllPatternEntryAccess().getPackageKeyword_0()); } | ||
3985 | ) | ||
3986 | ; | ||
3987 | finally { | ||
3988 | restoreStackSize(stackSize); | ||
3989 | } | ||
3990 | |||
3991 | rule__AllPatternEntry__Group__1 | ||
3992 | @init { | ||
3993 | int stackSize = keepStackSize(); | ||
3994 | } | ||
3995 | : | ||
3996 | rule__AllPatternEntry__Group__1__Impl | ||
3997 | rule__AllPatternEntry__Group__2 | ||
3998 | ; | ||
3999 | finally { | ||
4000 | restoreStackSize(stackSize); | ||
4001 | } | ||
4002 | |||
4003 | rule__AllPatternEntry__Group__1__Impl | ||
4004 | @init { | ||
4005 | int stackSize = keepStackSize(); | ||
4006 | } | ||
4007 | : | ||
4008 | ( | ||
4009 | { before(grammarAccess.getAllPatternEntryAccess().getPackageAssignment_1()); } | ||
4010 | (rule__AllPatternEntry__PackageAssignment_1) | ||
4011 | { after(grammarAccess.getAllPatternEntryAccess().getPackageAssignment_1()); } | ||
4012 | ) | ||
4013 | ; | ||
4014 | finally { | ||
4015 | restoreStackSize(stackSize); | ||
4016 | } | ||
4017 | |||
4018 | rule__AllPatternEntry__Group__2 | ||
4019 | @init { | ||
4020 | int stackSize = keepStackSize(); | ||
4021 | } | ||
4022 | : | ||
4023 | rule__AllPatternEntry__Group__2__Impl | ||
4024 | ; | ||
4025 | finally { | ||
4026 | restoreStackSize(stackSize); | ||
4027 | } | ||
4028 | |||
4029 | rule__AllPatternEntry__Group__2__Impl | ||
4030 | @init { | ||
4031 | int stackSize = keepStackSize(); | ||
4032 | } | ||
4033 | : | ||
4034 | ( | ||
4035 | { before(grammarAccess.getAllPatternEntryAccess().getGroup_2()); } | ||
4036 | (rule__AllPatternEntry__Group_2__0)? | ||
4037 | { after(grammarAccess.getAllPatternEntryAccess().getGroup_2()); } | ||
4038 | ) | ||
4039 | ; | ||
4040 | finally { | ||
4041 | restoreStackSize(stackSize); | ||
4042 | } | ||
4043 | |||
4044 | |||
4045 | rule__AllPatternEntry__Group_2__0 | ||
4046 | @init { | ||
4047 | int stackSize = keepStackSize(); | ||
4048 | } | ||
4049 | : | ||
4050 | rule__AllPatternEntry__Group_2__0__Impl | ||
4051 | rule__AllPatternEntry__Group_2__1 | ||
4052 | ; | ||
4053 | finally { | ||
4054 | restoreStackSize(stackSize); | ||
4055 | } | ||
4056 | |||
4057 | rule__AllPatternEntry__Group_2__0__Impl | ||
4058 | @init { | ||
4059 | int stackSize = keepStackSize(); | ||
4060 | } | ||
4061 | : | ||
4062 | ( | ||
4063 | { before(grammarAccess.getAllPatternEntryAccess().getExcludingKeyword_2_0()); } | ||
4064 | 'excluding' | ||
4065 | { after(grammarAccess.getAllPatternEntryAccess().getExcludingKeyword_2_0()); } | ||
4066 | ) | ||
4067 | ; | ||
4068 | finally { | ||
4069 | restoreStackSize(stackSize); | ||
4070 | } | ||
4071 | |||
4072 | rule__AllPatternEntry__Group_2__1 | ||
4073 | @init { | ||
4074 | int stackSize = keepStackSize(); | ||
4075 | } | ||
4076 | : | ||
4077 | rule__AllPatternEntry__Group_2__1__Impl | ||
4078 | rule__AllPatternEntry__Group_2__2 | ||
4079 | ; | ||
4080 | finally { | ||
4081 | restoreStackSize(stackSize); | ||
4082 | } | ||
4083 | |||
4084 | rule__AllPatternEntry__Group_2__1__Impl | ||
4085 | @init { | ||
4086 | int stackSize = keepStackSize(); | ||
4087 | } | ||
4088 | : | ||
4089 | ( | ||
4090 | { before(grammarAccess.getAllPatternEntryAccess().getLeftCurlyBracketKeyword_2_1()); } | ||
4091 | '{' | ||
4092 | { after(grammarAccess.getAllPatternEntryAccess().getLeftCurlyBracketKeyword_2_1()); } | ||
4093 | ) | ||
4094 | ; | ||
4095 | finally { | ||
4096 | restoreStackSize(stackSize); | ||
4097 | } | ||
4098 | |||
4099 | rule__AllPatternEntry__Group_2__2 | ||
4100 | @init { | ||
4101 | int stackSize = keepStackSize(); | ||
4102 | } | ||
4103 | : | ||
4104 | rule__AllPatternEntry__Group_2__2__Impl | ||
4105 | rule__AllPatternEntry__Group_2__3 | ||
4106 | ; | ||
4107 | finally { | ||
4108 | restoreStackSize(stackSize); | ||
4109 | } | ||
4110 | |||
4111 | rule__AllPatternEntry__Group_2__2__Impl | ||
4112 | @init { | ||
4113 | int stackSize = keepStackSize(); | ||
4114 | } | ||
4115 | : | ||
4116 | ( | ||
4117 | { before(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_2()); } | ||
4118 | (rule__AllPatternEntry__ExclusuionAssignment_2_2) | ||
4119 | { after(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_2()); } | ||
4120 | ) | ||
4121 | ; | ||
4122 | finally { | ||
4123 | restoreStackSize(stackSize); | ||
4124 | } | ||
4125 | |||
4126 | rule__AllPatternEntry__Group_2__3 | ||
4127 | @init { | ||
4128 | int stackSize = keepStackSize(); | ||
4129 | } | ||
4130 | : | ||
4131 | rule__AllPatternEntry__Group_2__3__Impl | ||
4132 | rule__AllPatternEntry__Group_2__4 | ||
4133 | ; | ||
4134 | finally { | ||
4135 | restoreStackSize(stackSize); | ||
4136 | } | ||
4137 | |||
4138 | rule__AllPatternEntry__Group_2__3__Impl | ||
4139 | @init { | ||
4140 | int stackSize = keepStackSize(); | ||
4141 | } | ||
4142 | : | ||
4143 | ( | ||
4144 | { before(grammarAccess.getAllPatternEntryAccess().getGroup_2_3()); } | ||
4145 | (rule__AllPatternEntry__Group_2_3__0)* | ||
4146 | { after(grammarAccess.getAllPatternEntryAccess().getGroup_2_3()); } | ||
4147 | ) | ||
4148 | ; | ||
4149 | finally { | ||
4150 | restoreStackSize(stackSize); | ||
4151 | } | ||
4152 | |||
4153 | rule__AllPatternEntry__Group_2__4 | ||
4154 | @init { | ||
4155 | int stackSize = keepStackSize(); | ||
4156 | } | ||
4157 | : | ||
4158 | rule__AllPatternEntry__Group_2__4__Impl | ||
4159 | ; | ||
4160 | finally { | ||
4161 | restoreStackSize(stackSize); | ||
4162 | } | ||
4163 | |||
4164 | rule__AllPatternEntry__Group_2__4__Impl | ||
4165 | @init { | ||
4166 | int stackSize = keepStackSize(); | ||
4167 | } | ||
4168 | : | ||
4169 | ( | ||
4170 | { before(grammarAccess.getAllPatternEntryAccess().getRightCurlyBracketKeyword_2_4()); } | ||
4171 | '}' | ||
4172 | { after(grammarAccess.getAllPatternEntryAccess().getRightCurlyBracketKeyword_2_4()); } | ||
4173 | ) | ||
4174 | ; | ||
4175 | finally { | ||
4176 | restoreStackSize(stackSize); | ||
4177 | } | ||
4178 | |||
4179 | |||
4180 | rule__AllPatternEntry__Group_2_3__0 | ||
4181 | @init { | ||
4182 | int stackSize = keepStackSize(); | ||
4183 | } | ||
4184 | : | ||
4185 | rule__AllPatternEntry__Group_2_3__0__Impl | ||
4186 | rule__AllPatternEntry__Group_2_3__1 | ||
4187 | ; | ||
4188 | finally { | ||
4189 | restoreStackSize(stackSize); | ||
4190 | } | ||
4191 | |||
4192 | rule__AllPatternEntry__Group_2_3__0__Impl | ||
4193 | @init { | ||
4194 | int stackSize = keepStackSize(); | ||
4195 | } | ||
4196 | : | ||
4197 | ( | ||
4198 | { before(grammarAccess.getAllPatternEntryAccess().getCommaKeyword_2_3_0()); } | ||
4199 | ',' | ||
4200 | { after(grammarAccess.getAllPatternEntryAccess().getCommaKeyword_2_3_0()); } | ||
4201 | ) | ||
4202 | ; | ||
4203 | finally { | ||
4204 | restoreStackSize(stackSize); | ||
4205 | } | ||
4206 | |||
4207 | rule__AllPatternEntry__Group_2_3__1 | ||
4208 | @init { | ||
4209 | int stackSize = keepStackSize(); | ||
4210 | } | ||
4211 | : | ||
4212 | rule__AllPatternEntry__Group_2_3__1__Impl | ||
4213 | ; | ||
4214 | finally { | ||
4215 | restoreStackSize(stackSize); | ||
4216 | } | ||
4217 | |||
4218 | rule__AllPatternEntry__Group_2_3__1__Impl | ||
4219 | @init { | ||
4220 | int stackSize = keepStackSize(); | ||
4221 | } | ||
4222 | : | ||
4223 | ( | ||
4224 | { before(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_3_1()); } | ||
4225 | (rule__AllPatternEntry__ExclusuionAssignment_2_3_1) | ||
4226 | { after(grammarAccess.getAllPatternEntryAccess().getExclusuionAssignment_2_3_1()); } | ||
4227 | ) | ||
4228 | ; | ||
4229 | finally { | ||
4230 | restoreStackSize(stackSize); | ||
4231 | } | ||
4232 | |||
4233 | |||
4234 | rule__PatternElement__Group__0 | ||
4235 | @init { | ||
4236 | int stackSize = keepStackSize(); | ||
4237 | } | ||
4238 | : | ||
4239 | rule__PatternElement__Group__0__Impl | ||
4240 | rule__PatternElement__Group__1 | ||
4241 | ; | ||
4242 | finally { | ||
4243 | restoreStackSize(stackSize); | ||
4244 | } | ||
4245 | |||
4246 | rule__PatternElement__Group__0__Impl | ||
4247 | @init { | ||
4248 | int stackSize = keepStackSize(); | ||
4249 | } | ||
4250 | : | ||
4251 | ( | ||
4252 | { before(grammarAccess.getPatternElementAccess().getGroup_0()); } | ||
4253 | (rule__PatternElement__Group_0__0)? | ||
4254 | { after(grammarAccess.getPatternElementAccess().getGroup_0()); } | ||
4255 | ) | ||
4256 | ; | ||
4257 | finally { | ||
4258 | restoreStackSize(stackSize); | ||
4259 | } | ||
4260 | |||
4261 | rule__PatternElement__Group__1 | ||
4262 | @init { | ||
4263 | int stackSize = keepStackSize(); | ||
4264 | } | ||
4265 | : | ||
4266 | rule__PatternElement__Group__1__Impl | ||
4267 | ; | ||
4268 | finally { | ||
4269 | restoreStackSize(stackSize); | ||
4270 | } | ||
4271 | |||
4272 | rule__PatternElement__Group__1__Impl | ||
4273 | @init { | ||
4274 | int stackSize = keepStackSize(); | ||
4275 | } | ||
4276 | : | ||
4277 | ( | ||
4278 | { before(grammarAccess.getPatternElementAccess().getPatternAssignment_1()); } | ||
4279 | (rule__PatternElement__PatternAssignment_1) | ||
4280 | { after(grammarAccess.getPatternElementAccess().getPatternAssignment_1()); } | ||
4281 | ) | ||
4282 | ; | ||
4283 | finally { | ||
4284 | restoreStackSize(stackSize); | ||
4285 | } | ||
4286 | |||
4287 | |||
4288 | rule__PatternElement__Group_0__0 | ||
4289 | @init { | ||
4290 | int stackSize = keepStackSize(); | ||
4291 | } | ||
4292 | : | ||
4293 | rule__PatternElement__Group_0__0__Impl | ||
4294 | rule__PatternElement__Group_0__1 | ||
4295 | ; | ||
4296 | finally { | ||
4297 | restoreStackSize(stackSize); | ||
4298 | } | ||
4299 | |||
4300 | rule__PatternElement__Group_0__0__Impl | ||
4301 | @init { | ||
4302 | int stackSize = keepStackSize(); | ||
4303 | } | ||
4304 | : | ||
4305 | ( | ||
4306 | { before(grammarAccess.getPatternElementAccess().getPackageAssignment_0_0()); } | ||
4307 | (rule__PatternElement__PackageAssignment_0_0) | ||
4308 | { after(grammarAccess.getPatternElementAccess().getPackageAssignment_0_0()); } | ||
4309 | ) | ||
4310 | ; | ||
4311 | finally { | ||
4312 | restoreStackSize(stackSize); | ||
4313 | } | ||
4314 | |||
4315 | rule__PatternElement__Group_0__1 | ||
4316 | @init { | ||
4317 | int stackSize = keepStackSize(); | ||
4318 | } | ||
4319 | : | ||
4320 | rule__PatternElement__Group_0__1__Impl | ||
4321 | ; | ||
4322 | finally { | ||
4323 | restoreStackSize(stackSize); | ||
4324 | } | ||
4325 | |||
4326 | rule__PatternElement__Group_0__1__Impl | ||
4327 | @init { | ||
4328 | int stackSize = keepStackSize(); | ||
4329 | } | ||
4330 | : | ||
4331 | ( | ||
4332 | { before(grammarAccess.getPatternElementAccess().getColonColonKeyword_0_1()); } | ||
4333 | '::' | ||
4334 | { after(grammarAccess.getPatternElementAccess().getColonColonKeyword_0_1()); } | ||
4335 | ) | ||
4336 | ; | ||
4337 | finally { | ||
4338 | restoreStackSize(stackSize); | ||
4339 | } | ||
4340 | |||
4341 | |||
4342 | rule__GraphPatternDeclaration__Group__0 | ||
4343 | @init { | ||
4344 | int stackSize = keepStackSize(); | ||
4345 | } | ||
4346 | : | ||
4347 | rule__GraphPatternDeclaration__Group__0__Impl | ||
4348 | rule__GraphPatternDeclaration__Group__1 | ||
4349 | ; | ||
4350 | finally { | ||
4351 | restoreStackSize(stackSize); | ||
4352 | } | ||
4353 | |||
4354 | rule__GraphPatternDeclaration__Group__0__Impl | ||
4355 | @init { | ||
4356 | int stackSize = keepStackSize(); | ||
4357 | } | ||
4358 | : | ||
4359 | ( | ||
4360 | { before(grammarAccess.getGraphPatternDeclarationAccess().getPatternsKeyword_0()); } | ||
4361 | 'patterns' | ||
4362 | { after(grammarAccess.getGraphPatternDeclarationAccess().getPatternsKeyword_0()); } | ||
4363 | ) | ||
4364 | ; | ||
4365 | finally { | ||
4366 | restoreStackSize(stackSize); | ||
4367 | } | ||
4368 | |||
4369 | rule__GraphPatternDeclaration__Group__1 | ||
4370 | @init { | ||
4371 | int stackSize = keepStackSize(); | ||
4372 | } | ||
4373 | : | ||
4374 | rule__GraphPatternDeclaration__Group__1__Impl | ||
4375 | rule__GraphPatternDeclaration__Group__2 | ||
4376 | ; | ||
4377 | finally { | ||
4378 | restoreStackSize(stackSize); | ||
4379 | } | ||
4380 | |||
4381 | rule__GraphPatternDeclaration__Group__1__Impl | ||
4382 | @init { | ||
4383 | int stackSize = keepStackSize(); | ||
4384 | } | ||
4385 | : | ||
4386 | ( | ||
4387 | { before(grammarAccess.getGraphPatternDeclarationAccess().getNameAssignment_1()); } | ||
4388 | (rule__GraphPatternDeclaration__NameAssignment_1) | ||
4389 | { after(grammarAccess.getGraphPatternDeclarationAccess().getNameAssignment_1()); } | ||
4390 | ) | ||
4391 | ; | ||
4392 | finally { | ||
4393 | restoreStackSize(stackSize); | ||
4394 | } | ||
4395 | |||
4396 | rule__GraphPatternDeclaration__Group__2 | ||
4397 | @init { | ||
4398 | int stackSize = keepStackSize(); | ||
4399 | } | ||
4400 | : | ||
4401 | rule__GraphPatternDeclaration__Group__2__Impl | ||
4402 | ; | ||
4403 | finally { | ||
4404 | restoreStackSize(stackSize); | ||
4405 | } | ||
4406 | |||
4407 | rule__GraphPatternDeclaration__Group__2__Impl | ||
4408 | @init { | ||
4409 | int stackSize = keepStackSize(); | ||
4410 | } | ||
4411 | : | ||
4412 | ( | ||
4413 | { before(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationAssignment_2()); } | ||
4414 | (rule__GraphPatternDeclaration__SpecificationAssignment_2) | ||
4415 | { after(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationAssignment_2()); } | ||
4416 | ) | ||
4417 | ; | ||
4418 | finally { | ||
4419 | restoreStackSize(stackSize); | ||
4420 | } | ||
4421 | |||
4422 | |||
4423 | rule__ConfigSpecification__Group__0 | ||
4424 | @init { | ||
4425 | int stackSize = keepStackSize(); | ||
4426 | } | ||
4427 | : | ||
4428 | rule__ConfigSpecification__Group__0__Impl | ||
4429 | rule__ConfigSpecification__Group__1 | ||
4430 | ; | ||
4431 | finally { | ||
4432 | restoreStackSize(stackSize); | ||
4433 | } | ||
4434 | |||
4435 | rule__ConfigSpecification__Group__0__Impl | ||
4436 | @init { | ||
4437 | int stackSize = keepStackSize(); | ||
4438 | } | ||
4439 | : | ||
4440 | ( | ||
4441 | { before(grammarAccess.getConfigSpecificationAccess().getConfigSpecificationAction_0()); } | ||
4442 | () | ||
4443 | { after(grammarAccess.getConfigSpecificationAccess().getConfigSpecificationAction_0()); } | ||
4444 | ) | ||
4445 | ; | ||
4446 | finally { | ||
4447 | restoreStackSize(stackSize); | ||
4448 | } | ||
4449 | |||
4450 | rule__ConfigSpecification__Group__1 | ||
4451 | @init { | ||
4452 | int stackSize = keepStackSize(); | ||
4453 | } | ||
4454 | : | ||
4455 | rule__ConfigSpecification__Group__1__Impl | ||
4456 | rule__ConfigSpecification__Group__2 | ||
4457 | ; | ||
4458 | finally { | ||
4459 | restoreStackSize(stackSize); | ||
4460 | } | ||
4461 | |||
4462 | rule__ConfigSpecification__Group__1__Impl | ||
4463 | @init { | ||
4464 | int stackSize = keepStackSize(); | ||
4465 | } | ||
4466 | : | ||
4467 | ( | ||
4468 | { before(grammarAccess.getConfigSpecificationAccess().getLeftCurlyBracketKeyword_1()); } | ||
4469 | '{' | ||
4470 | { after(grammarAccess.getConfigSpecificationAccess().getLeftCurlyBracketKeyword_1()); } | ||
4471 | ) | ||
4472 | ; | ||
4473 | finally { | ||
4474 | restoreStackSize(stackSize); | ||
4475 | } | ||
4476 | |||
4477 | rule__ConfigSpecification__Group__2 | ||
4478 | @init { | ||
4479 | int stackSize = keepStackSize(); | ||
4480 | } | ||
4481 | : | ||
4482 | rule__ConfigSpecification__Group__2__Impl | ||
4483 | rule__ConfigSpecification__Group__3 | ||
4484 | ; | ||
4485 | finally { | ||
4486 | restoreStackSize(stackSize); | ||
4487 | } | ||
4488 | |||
4489 | rule__ConfigSpecification__Group__2__Impl | ||
4490 | @init { | ||
4491 | int stackSize = keepStackSize(); | ||
4492 | } | ||
4493 | : | ||
4494 | ( | ||
4495 | { before(grammarAccess.getConfigSpecificationAccess().getGroup_2()); } | ||
4496 | (rule__ConfigSpecification__Group_2__0)? | ||
4497 | { after(grammarAccess.getConfigSpecificationAccess().getGroup_2()); } | ||
4498 | ) | ||
4499 | ; | ||
4500 | finally { | ||
4501 | restoreStackSize(stackSize); | ||
4502 | } | ||
4503 | |||
4504 | rule__ConfigSpecification__Group__3 | ||
4505 | @init { | ||
4506 | int stackSize = keepStackSize(); | ||
4507 | } | ||
4508 | : | ||
4509 | rule__ConfigSpecification__Group__3__Impl | ||
4510 | ; | ||
4511 | finally { | ||
4512 | restoreStackSize(stackSize); | ||
4513 | } | ||
4514 | |||
4515 | rule__ConfigSpecification__Group__3__Impl | ||
4516 | @init { | ||
4517 | int stackSize = keepStackSize(); | ||
4518 | } | ||
4519 | : | ||
4520 | ( | ||
4521 | { before(grammarAccess.getConfigSpecificationAccess().getRightCurlyBracketKeyword_3()); } | ||
4522 | '}' | ||
4523 | { after(grammarAccess.getConfigSpecificationAccess().getRightCurlyBracketKeyword_3()); } | ||
4524 | ) | ||
4525 | ; | ||
4526 | finally { | ||
4527 | restoreStackSize(stackSize); | ||
4528 | } | ||
4529 | |||
4530 | |||
4531 | rule__ConfigSpecification__Group_2__0 | ||
4532 | @init { | ||
4533 | int stackSize = keepStackSize(); | ||
4534 | } | ||
4535 | : | ||
4536 | rule__ConfigSpecification__Group_2__0__Impl | ||
4537 | rule__ConfigSpecification__Group_2__1 | ||
4538 | ; | ||
4539 | finally { | ||
4540 | restoreStackSize(stackSize); | ||
4541 | } | ||
4542 | |||
4543 | rule__ConfigSpecification__Group_2__0__Impl | ||
4544 | @init { | ||
4545 | int stackSize = keepStackSize(); | ||
4546 | } | ||
4547 | : | ||
4548 | ( | ||
4549 | { before(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_0()); } | ||
4550 | (rule__ConfigSpecification__EntriesAssignment_2_0) | ||
4551 | { after(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_0()); } | ||
4552 | ) | ||
4553 | ; | ||
4554 | finally { | ||
4555 | restoreStackSize(stackSize); | ||
4556 | } | ||
4557 | |||
4558 | rule__ConfigSpecification__Group_2__1 | ||
4559 | @init { | ||
4560 | int stackSize = keepStackSize(); | ||
4561 | } | ||
4562 | : | ||
4563 | rule__ConfigSpecification__Group_2__1__Impl | ||
4564 | ; | ||
4565 | finally { | ||
4566 | restoreStackSize(stackSize); | ||
4567 | } | ||
4568 | |||
4569 | rule__ConfigSpecification__Group_2__1__Impl | ||
4570 | @init { | ||
4571 | int stackSize = keepStackSize(); | ||
4572 | } | ||
4573 | : | ||
4574 | ( | ||
4575 | { before(grammarAccess.getConfigSpecificationAccess().getGroup_2_1()); } | ||
4576 | (rule__ConfigSpecification__Group_2_1__0)* | ||
4577 | { after(grammarAccess.getConfigSpecificationAccess().getGroup_2_1()); } | ||
4578 | ) | ||
4579 | ; | ||
4580 | finally { | ||
4581 | restoreStackSize(stackSize); | ||
4582 | } | ||
4583 | |||
4584 | |||
4585 | rule__ConfigSpecification__Group_2_1__0 | ||
4586 | @init { | ||
4587 | int stackSize = keepStackSize(); | ||
4588 | } | ||
4589 | : | ||
4590 | rule__ConfigSpecification__Group_2_1__0__Impl | ||
4591 | rule__ConfigSpecification__Group_2_1__1 | ||
4592 | ; | ||
4593 | finally { | ||
4594 | restoreStackSize(stackSize); | ||
4595 | } | ||
4596 | |||
4597 | rule__ConfigSpecification__Group_2_1__0__Impl | ||
4598 | @init { | ||
4599 | int stackSize = keepStackSize(); | ||
4600 | } | ||
4601 | : | ||
4602 | ( | ||
4603 | { before(grammarAccess.getConfigSpecificationAccess().getCommaKeyword_2_1_0()); } | ||
4604 | ',' | ||
4605 | { after(grammarAccess.getConfigSpecificationAccess().getCommaKeyword_2_1_0()); } | ||
4606 | ) | ||
4607 | ; | ||
4608 | finally { | ||
4609 | restoreStackSize(stackSize); | ||
4610 | } | ||
4611 | |||
4612 | rule__ConfigSpecification__Group_2_1__1 | ||
4613 | @init { | ||
4614 | int stackSize = keepStackSize(); | ||
4615 | } | ||
4616 | : | ||
4617 | rule__ConfigSpecification__Group_2_1__1__Impl | ||
4618 | ; | ||
4619 | finally { | ||
4620 | restoreStackSize(stackSize); | ||
4621 | } | ||
4622 | |||
4623 | rule__ConfigSpecification__Group_2_1__1__Impl | ||
4624 | @init { | ||
4625 | int stackSize = keepStackSize(); | ||
4626 | } | ||
4627 | : | ||
4628 | ( | ||
4629 | { before(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_1_1()); } | ||
4630 | (rule__ConfigSpecification__EntriesAssignment_2_1_1) | ||
4631 | { after(grammarAccess.getConfigSpecificationAccess().getEntriesAssignment_2_1_1()); } | ||
4632 | ) | ||
4633 | ; | ||
4634 | finally { | ||
4635 | restoreStackSize(stackSize); | ||
4636 | } | ||
4637 | |||
4638 | |||
4639 | rule__ConfigDeclaration__Group__0 | ||
4640 | @init { | ||
4641 | int stackSize = keepStackSize(); | ||
4642 | } | ||
4643 | : | ||
4644 | rule__ConfigDeclaration__Group__0__Impl | ||
4645 | rule__ConfigDeclaration__Group__1 | ||
4646 | ; | ||
4647 | finally { | ||
4648 | restoreStackSize(stackSize); | ||
4649 | } | ||
4650 | |||
4651 | rule__ConfigDeclaration__Group__0__Impl | ||
4652 | @init { | ||
4653 | int stackSize = keepStackSize(); | ||
4654 | } | ||
4655 | : | ||
4656 | ( | ||
4657 | { before(grammarAccess.getConfigDeclarationAccess().getConfigKeyword_0()); } | ||
4658 | 'config' | ||
4659 | { after(grammarAccess.getConfigDeclarationAccess().getConfigKeyword_0()); } | ||
4660 | ) | ||
4661 | ; | ||
4662 | finally { | ||
4663 | restoreStackSize(stackSize); | ||
4664 | } | ||
4665 | |||
4666 | rule__ConfigDeclaration__Group__1 | ||
4667 | @init { | ||
4668 | int stackSize = keepStackSize(); | ||
4669 | } | ||
4670 | : | ||
4671 | rule__ConfigDeclaration__Group__1__Impl | ||
4672 | rule__ConfigDeclaration__Group__2 | ||
4673 | ; | ||
4674 | finally { | ||
4675 | restoreStackSize(stackSize); | ||
4676 | } | ||
4677 | |||
4678 | rule__ConfigDeclaration__Group__1__Impl | ||
4679 | @init { | ||
4680 | int stackSize = keepStackSize(); | ||
4681 | } | ||
4682 | : | ||
4683 | ( | ||
4684 | { before(grammarAccess.getConfigDeclarationAccess().getNameAssignment_1()); } | ||
4685 | (rule__ConfigDeclaration__NameAssignment_1) | ||
4686 | { after(grammarAccess.getConfigDeclarationAccess().getNameAssignment_1()); } | ||
4687 | ) | ||
4688 | ; | ||
4689 | finally { | ||
4690 | restoreStackSize(stackSize); | ||
4691 | } | ||
4692 | |||
4693 | rule__ConfigDeclaration__Group__2 | ||
4694 | @init { | ||
4695 | int stackSize = keepStackSize(); | ||
4696 | } | ||
4697 | : | ||
4698 | rule__ConfigDeclaration__Group__2__Impl | ||
4699 | ; | ||
4700 | finally { | ||
4701 | restoreStackSize(stackSize); | ||
4702 | } | ||
4703 | |||
4704 | rule__ConfigDeclaration__Group__2__Impl | ||
4705 | @init { | ||
4706 | int stackSize = keepStackSize(); | ||
4707 | } | ||
4708 | : | ||
4709 | ( | ||
4710 | { before(grammarAccess.getConfigDeclarationAccess().getSpecificationAssignment_2()); } | ||
4711 | (rule__ConfigDeclaration__SpecificationAssignment_2) | ||
4712 | { after(grammarAccess.getConfigDeclarationAccess().getSpecificationAssignment_2()); } | ||
4713 | ) | ||
4714 | ; | ||
4715 | finally { | ||
4716 | restoreStackSize(stackSize); | ||
4717 | } | ||
4718 | |||
4719 | |||
4720 | rule__ConfigEntry__Group__0 | ||
4721 | @init { | ||
4722 | int stackSize = keepStackSize(); | ||
4723 | } | ||
4724 | : | ||
4725 | rule__ConfigEntry__Group__0__Impl | ||
4726 | rule__ConfigEntry__Group__1 | ||
4727 | ; | ||
4728 | finally { | ||
4729 | restoreStackSize(stackSize); | ||
4730 | } | ||
4731 | |||
4732 | rule__ConfigEntry__Group__0__Impl | ||
4733 | @init { | ||
4734 | int stackSize = keepStackSize(); | ||
4735 | } | ||
4736 | : | ||
4737 | ( | ||
4738 | { before(grammarAccess.getConfigEntryAccess().getKeyAssignment_0()); } | ||
4739 | (rule__ConfigEntry__KeyAssignment_0) | ||
4740 | { after(grammarAccess.getConfigEntryAccess().getKeyAssignment_0()); } | ||
4741 | ) | ||
4742 | ; | ||
4743 | finally { | ||
4744 | restoreStackSize(stackSize); | ||
4745 | } | ||
4746 | |||
4747 | rule__ConfigEntry__Group__1 | ||
4748 | @init { | ||
4749 | int stackSize = keepStackSize(); | ||
4750 | } | ||
4751 | : | ||
4752 | rule__ConfigEntry__Group__1__Impl | ||
4753 | rule__ConfigEntry__Group__2 | ||
4754 | ; | ||
4755 | finally { | ||
4756 | restoreStackSize(stackSize); | ||
4757 | } | ||
4758 | |||
4759 | rule__ConfigEntry__Group__1__Impl | ||
4760 | @init { | ||
4761 | int stackSize = keepStackSize(); | ||
4762 | } | ||
4763 | : | ||
4764 | ( | ||
4765 | { before(grammarAccess.getConfigEntryAccess().getEqualsSignKeyword_1()); } | ||
4766 | '=' | ||
4767 | { after(grammarAccess.getConfigEntryAccess().getEqualsSignKeyword_1()); } | ||
4768 | ) | ||
4769 | ; | ||
4770 | finally { | ||
4771 | restoreStackSize(stackSize); | ||
4772 | } | ||
4773 | |||
4774 | rule__ConfigEntry__Group__2 | ||
4775 | @init { | ||
4776 | int stackSize = keepStackSize(); | ||
4777 | } | ||
4778 | : | ||
4779 | rule__ConfigEntry__Group__2__Impl | ||
4780 | ; | ||
4781 | finally { | ||
4782 | restoreStackSize(stackSize); | ||
4783 | } | ||
4784 | |||
4785 | rule__ConfigEntry__Group__2__Impl | ||
4786 | @init { | ||
4787 | int stackSize = keepStackSize(); | ||
4788 | } | ||
4789 | : | ||
4790 | ( | ||
4791 | { before(grammarAccess.getConfigEntryAccess().getValueAssignment_2()); } | ||
4792 | (rule__ConfigEntry__ValueAssignment_2) | ||
4793 | { after(grammarAccess.getConfigEntryAccess().getValueAssignment_2()); } | ||
4794 | ) | ||
4795 | ; | ||
4796 | finally { | ||
4797 | restoreStackSize(stackSize); | ||
4798 | } | ||
4799 | |||
4800 | |||
4801 | rule__ScopeSpecification__Group__0 | ||
4802 | @init { | ||
4803 | int stackSize = keepStackSize(); | ||
4804 | } | ||
4805 | : | ||
4806 | rule__ScopeSpecification__Group__0__Impl | ||
4807 | rule__ScopeSpecification__Group__1 | ||
4808 | ; | ||
4809 | finally { | ||
4810 | restoreStackSize(stackSize); | ||
4811 | } | ||
4812 | |||
4813 | rule__ScopeSpecification__Group__0__Impl | ||
4814 | @init { | ||
4815 | int stackSize = keepStackSize(); | ||
4816 | } | ||
4817 | : | ||
4818 | ( | ||
4819 | { before(grammarAccess.getScopeSpecificationAccess().getScopeSpecificationAction_0()); } | ||
4820 | () | ||
4821 | { after(grammarAccess.getScopeSpecificationAccess().getScopeSpecificationAction_0()); } | ||
4822 | ) | ||
4823 | ; | ||
4824 | finally { | ||
4825 | restoreStackSize(stackSize); | ||
4826 | } | ||
4827 | |||
4828 | rule__ScopeSpecification__Group__1 | ||
4829 | @init { | ||
4830 | int stackSize = keepStackSize(); | ||
4831 | } | ||
4832 | : | ||
4833 | rule__ScopeSpecification__Group__1__Impl | ||
4834 | rule__ScopeSpecification__Group__2 | ||
4835 | ; | ||
4836 | finally { | ||
4837 | restoreStackSize(stackSize); | ||
4838 | } | ||
4839 | |||
4840 | rule__ScopeSpecification__Group__1__Impl | ||
4841 | @init { | ||
4842 | int stackSize = keepStackSize(); | ||
4843 | } | ||
4844 | : | ||
4845 | ( | ||
4846 | { before(grammarAccess.getScopeSpecificationAccess().getLeftCurlyBracketKeyword_1()); } | ||
4847 | '{' | ||
4848 | { after(grammarAccess.getScopeSpecificationAccess().getLeftCurlyBracketKeyword_1()); } | ||
4849 | ) | ||
4850 | ; | ||
4851 | finally { | ||
4852 | restoreStackSize(stackSize); | ||
4853 | } | ||
4854 | |||
4855 | rule__ScopeSpecification__Group__2 | ||
4856 | @init { | ||
4857 | int stackSize = keepStackSize(); | ||
4858 | } | ||
4859 | : | ||
4860 | rule__ScopeSpecification__Group__2__Impl | ||
4861 | rule__ScopeSpecification__Group__3 | ||
4862 | ; | ||
4863 | finally { | ||
4864 | restoreStackSize(stackSize); | ||
4865 | } | ||
4866 | |||
4867 | rule__ScopeSpecification__Group__2__Impl | ||
4868 | @init { | ||
4869 | int stackSize = keepStackSize(); | ||
4870 | } | ||
4871 | : | ||
4872 | ( | ||
4873 | { before(grammarAccess.getScopeSpecificationAccess().getGroup_2()); } | ||
4874 | (rule__ScopeSpecification__Group_2__0)? | ||
4875 | { after(grammarAccess.getScopeSpecificationAccess().getGroup_2()); } | ||
4876 | ) | ||
4877 | ; | ||
4878 | finally { | ||
4879 | restoreStackSize(stackSize); | ||
4880 | } | ||
4881 | |||
4882 | rule__ScopeSpecification__Group__3 | ||
4883 | @init { | ||
4884 | int stackSize = keepStackSize(); | ||
4885 | } | ||
4886 | : | ||
4887 | rule__ScopeSpecification__Group__3__Impl | ||
4888 | ; | ||
4889 | finally { | ||
4890 | restoreStackSize(stackSize); | ||
4891 | } | ||
4892 | |||
4893 | rule__ScopeSpecification__Group__3__Impl | ||
4894 | @init { | ||
4895 | int stackSize = keepStackSize(); | ||
4896 | } | ||
4897 | : | ||
4898 | ( | ||
4899 | { before(grammarAccess.getScopeSpecificationAccess().getRightCurlyBracketKeyword_3()); } | ||
4900 | '}' | ||
4901 | { after(grammarAccess.getScopeSpecificationAccess().getRightCurlyBracketKeyword_3()); } | ||
4902 | ) | ||
4903 | ; | ||
4904 | finally { | ||
4905 | restoreStackSize(stackSize); | ||
4906 | } | ||
4907 | |||
4908 | |||
4909 | rule__ScopeSpecification__Group_2__0 | ||
4910 | @init { | ||
4911 | int stackSize = keepStackSize(); | ||
4912 | } | ||
4913 | : | ||
4914 | rule__ScopeSpecification__Group_2__0__Impl | ||
4915 | rule__ScopeSpecification__Group_2__1 | ||
4916 | ; | ||
4917 | finally { | ||
4918 | restoreStackSize(stackSize); | ||
4919 | } | ||
4920 | |||
4921 | rule__ScopeSpecification__Group_2__0__Impl | ||
4922 | @init { | ||
4923 | int stackSize = keepStackSize(); | ||
4924 | } | ||
4925 | : | ||
4926 | ( | ||
4927 | { before(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_0()); } | ||
4928 | (rule__ScopeSpecification__ScopesAssignment_2_0) | ||
4929 | { after(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_0()); } | ||
4930 | ) | ||
4931 | ; | ||
4932 | finally { | ||
4933 | restoreStackSize(stackSize); | ||
4934 | } | ||
4935 | |||
4936 | rule__ScopeSpecification__Group_2__1 | ||
4937 | @init { | ||
4938 | int stackSize = keepStackSize(); | ||
4939 | } | ||
4940 | : | ||
4941 | rule__ScopeSpecification__Group_2__1__Impl | ||
4942 | ; | ||
4943 | finally { | ||
4944 | restoreStackSize(stackSize); | ||
4945 | } | ||
4946 | |||
4947 | rule__ScopeSpecification__Group_2__1__Impl | ||
4948 | @init { | ||
4949 | int stackSize = keepStackSize(); | ||
4950 | } | ||
4951 | : | ||
4952 | ( | ||
4953 | { before(grammarAccess.getScopeSpecificationAccess().getGroup_2_1()); } | ||
4954 | (rule__ScopeSpecification__Group_2_1__0)* | ||
4955 | { after(grammarAccess.getScopeSpecificationAccess().getGroup_2_1()); } | ||
4956 | ) | ||
4957 | ; | ||
4958 | finally { | ||
4959 | restoreStackSize(stackSize); | ||
4960 | } | ||
4961 | |||
4962 | |||
4963 | rule__ScopeSpecification__Group_2_1__0 | ||
4964 | @init { | ||
4965 | int stackSize = keepStackSize(); | ||
4966 | } | ||
4967 | : | ||
4968 | rule__ScopeSpecification__Group_2_1__0__Impl | ||
4969 | rule__ScopeSpecification__Group_2_1__1 | ||
4970 | ; | ||
4971 | finally { | ||
4972 | restoreStackSize(stackSize); | ||
4973 | } | ||
4974 | |||
4975 | rule__ScopeSpecification__Group_2_1__0__Impl | ||
4976 | @init { | ||
4977 | int stackSize = keepStackSize(); | ||
4978 | } | ||
4979 | : | ||
4980 | ( | ||
4981 | { before(grammarAccess.getScopeSpecificationAccess().getCommaKeyword_2_1_0()); } | ||
4982 | ',' | ||
4983 | { after(grammarAccess.getScopeSpecificationAccess().getCommaKeyword_2_1_0()); } | ||
4984 | ) | ||
4985 | ; | ||
4986 | finally { | ||
4987 | restoreStackSize(stackSize); | ||
4988 | } | ||
4989 | |||
4990 | rule__ScopeSpecification__Group_2_1__1 | ||
4991 | @init { | ||
4992 | int stackSize = keepStackSize(); | ||
4993 | } | ||
4994 | : | ||
4995 | rule__ScopeSpecification__Group_2_1__1__Impl | ||
4996 | ; | ||
4997 | finally { | ||
4998 | restoreStackSize(stackSize); | ||
4999 | } | ||
5000 | |||
5001 | rule__ScopeSpecification__Group_2_1__1__Impl | ||
5002 | @init { | ||
5003 | int stackSize = keepStackSize(); | ||
5004 | } | ||
5005 | : | ||
5006 | ( | ||
5007 | { before(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_1_1()); } | ||
5008 | (rule__ScopeSpecification__ScopesAssignment_2_1_1) | ||
5009 | { after(grammarAccess.getScopeSpecificationAccess().getScopesAssignment_2_1_1()); } | ||
5010 | ) | ||
5011 | ; | ||
5012 | finally { | ||
5013 | restoreStackSize(stackSize); | ||
5014 | } | ||
5015 | |||
5016 | |||
5017 | rule__ClassTypeScope__Group__0 | ||
5018 | @init { | ||
5019 | int stackSize = keepStackSize(); | ||
5020 | } | ||
5021 | : | ||
5022 | rule__ClassTypeScope__Group__0__Impl | ||
5023 | rule__ClassTypeScope__Group__1 | ||
5024 | ; | ||
5025 | finally { | ||
5026 | restoreStackSize(stackSize); | ||
5027 | } | ||
5028 | |||
5029 | rule__ClassTypeScope__Group__0__Impl | ||
5030 | @init { | ||
5031 | int stackSize = keepStackSize(); | ||
5032 | } | ||
5033 | : | ||
5034 | ( | ||
5035 | { before(grammarAccess.getClassTypeScopeAccess().getNumberSignKeyword_0()); } | ||
5036 | '#' | ||
5037 | { after(grammarAccess.getClassTypeScopeAccess().getNumberSignKeyword_0()); } | ||
5038 | ) | ||
5039 | ; | ||
5040 | finally { | ||
5041 | restoreStackSize(stackSize); | ||
5042 | } | ||
5043 | |||
5044 | rule__ClassTypeScope__Group__1 | ||
5045 | @init { | ||
5046 | int stackSize = keepStackSize(); | ||
5047 | } | ||
5048 | : | ||
5049 | rule__ClassTypeScope__Group__1__Impl | ||
5050 | rule__ClassTypeScope__Group__2 | ||
5051 | ; | ||
5052 | finally { | ||
5053 | restoreStackSize(stackSize); | ||
5054 | } | ||
5055 | |||
5056 | rule__ClassTypeScope__Group__1__Impl | ||
5057 | @init { | ||
5058 | int stackSize = keepStackSize(); | ||
5059 | } | ||
5060 | : | ||
5061 | ( | ||
5062 | { before(grammarAccess.getClassTypeScopeAccess().getTypeAssignment_1()); } | ||
5063 | (rule__ClassTypeScope__TypeAssignment_1) | ||
5064 | { after(grammarAccess.getClassTypeScopeAccess().getTypeAssignment_1()); } | ||
5065 | ) | ||
5066 | ; | ||
5067 | finally { | ||
5068 | restoreStackSize(stackSize); | ||
5069 | } | ||
5070 | |||
5071 | rule__ClassTypeScope__Group__2 | ||
5072 | @init { | ||
5073 | int stackSize = keepStackSize(); | ||
5074 | } | ||
5075 | : | ||
5076 | rule__ClassTypeScope__Group__2__Impl | ||
5077 | rule__ClassTypeScope__Group__3 | ||
5078 | ; | ||
5079 | finally { | ||
5080 | restoreStackSize(stackSize); | ||
5081 | } | ||
5082 | |||
5083 | rule__ClassTypeScope__Group__2__Impl | ||
5084 | @init { | ||
5085 | int stackSize = keepStackSize(); | ||
5086 | } | ||
5087 | : | ||
5088 | ( | ||
5089 | { before(grammarAccess.getClassTypeScopeAccess().getAlternatives_2()); } | ||
5090 | (rule__ClassTypeScope__Alternatives_2) | ||
5091 | { after(grammarAccess.getClassTypeScopeAccess().getAlternatives_2()); } | ||
5092 | ) | ||
5093 | ; | ||
5094 | finally { | ||
5095 | restoreStackSize(stackSize); | ||
5096 | } | ||
5097 | |||
5098 | rule__ClassTypeScope__Group__3 | ||
5099 | @init { | ||
5100 | int stackSize = keepStackSize(); | ||
5101 | } | ||
5102 | : | ||
5103 | rule__ClassTypeScope__Group__3__Impl | ||
5104 | ; | ||
5105 | finally { | ||
5106 | restoreStackSize(stackSize); | ||
5107 | } | ||
5108 | |||
5109 | rule__ClassTypeScope__Group__3__Impl | ||
5110 | @init { | ||
5111 | int stackSize = keepStackSize(); | ||
5112 | } | ||
5113 | : | ||
5114 | ( | ||
5115 | { before(grammarAccess.getClassTypeScopeAccess().getAlternatives_3()); } | ||
5116 | (rule__ClassTypeScope__Alternatives_3) | ||
5117 | { after(grammarAccess.getClassTypeScopeAccess().getAlternatives_3()); } | ||
5118 | ) | ||
5119 | ; | ||
5120 | finally { | ||
5121 | restoreStackSize(stackSize); | ||
5122 | } | ||
5123 | |||
5124 | |||
5125 | rule__ObjectTypeScope__Group__0 | ||
5126 | @init { | ||
5127 | int stackSize = keepStackSize(); | ||
5128 | } | ||
5129 | : | ||
5130 | rule__ObjectTypeScope__Group__0__Impl | ||
5131 | rule__ObjectTypeScope__Group__1 | ||
5132 | ; | ||
5133 | finally { | ||
5134 | restoreStackSize(stackSize); | ||
5135 | } | ||
5136 | |||
5137 | rule__ObjectTypeScope__Group__0__Impl | ||
5138 | @init { | ||
5139 | int stackSize = keepStackSize(); | ||
5140 | } | ||
5141 | : | ||
5142 | ( | ||
5143 | { before(grammarAccess.getObjectTypeScopeAccess().getNumberSignKeyword_0()); } | ||
5144 | '#' | ||
5145 | { after(grammarAccess.getObjectTypeScopeAccess().getNumberSignKeyword_0()); } | ||
5146 | ) | ||
5147 | ; | ||
5148 | finally { | ||
5149 | restoreStackSize(stackSize); | ||
5150 | } | ||
5151 | |||
5152 | rule__ObjectTypeScope__Group__1 | ||
5153 | @init { | ||
5154 | int stackSize = keepStackSize(); | ||
5155 | } | ||
5156 | : | ||
5157 | rule__ObjectTypeScope__Group__1__Impl | ||
5158 | rule__ObjectTypeScope__Group__2 | ||
5159 | ; | ||
5160 | finally { | ||
5161 | restoreStackSize(stackSize); | ||
5162 | } | ||
5163 | |||
5164 | rule__ObjectTypeScope__Group__1__Impl | ||
5165 | @init { | ||
5166 | int stackSize = keepStackSize(); | ||
5167 | } | ||
5168 | : | ||
5169 | ( | ||
5170 | { before(grammarAccess.getObjectTypeScopeAccess().getTypeAssignment_1()); } | ||
5171 | (rule__ObjectTypeScope__TypeAssignment_1) | ||
5172 | { after(grammarAccess.getObjectTypeScopeAccess().getTypeAssignment_1()); } | ||
5173 | ) | ||
5174 | ; | ||
5175 | finally { | ||
5176 | restoreStackSize(stackSize); | ||
5177 | } | ||
5178 | |||
5179 | rule__ObjectTypeScope__Group__2 | ||
5180 | @init { | ||
5181 | int stackSize = keepStackSize(); | ||
5182 | } | ||
5183 | : | ||
5184 | rule__ObjectTypeScope__Group__2__Impl | ||
5185 | rule__ObjectTypeScope__Group__3 | ||
5186 | ; | ||
5187 | finally { | ||
5188 | restoreStackSize(stackSize); | ||
5189 | } | ||
5190 | |||
5191 | rule__ObjectTypeScope__Group__2__Impl | ||
5192 | @init { | ||
5193 | int stackSize = keepStackSize(); | ||
5194 | } | ||
5195 | : | ||
5196 | ( | ||
5197 | { before(grammarAccess.getObjectTypeScopeAccess().getAlternatives_2()); } | ||
5198 | (rule__ObjectTypeScope__Alternatives_2) | ||
5199 | { after(grammarAccess.getObjectTypeScopeAccess().getAlternatives_2()); } | ||
5200 | ) | ||
5201 | ; | ||
5202 | finally { | ||
5203 | restoreStackSize(stackSize); | ||
5204 | } | ||
5205 | |||
5206 | rule__ObjectTypeScope__Group__3 | ||
5207 | @init { | ||
5208 | int stackSize = keepStackSize(); | ||
5209 | } | ||
5210 | : | ||
5211 | rule__ObjectTypeScope__Group__3__Impl | ||
5212 | ; | ||
5213 | finally { | ||
5214 | restoreStackSize(stackSize); | ||
5215 | } | ||
5216 | |||
5217 | rule__ObjectTypeScope__Group__3__Impl | ||
5218 | @init { | ||
5219 | int stackSize = keepStackSize(); | ||
5220 | } | ||
5221 | : | ||
5222 | ( | ||
5223 | { before(grammarAccess.getObjectTypeScopeAccess().getAlternatives_3()); } | ||
5224 | (rule__ObjectTypeScope__Alternatives_3) | ||
5225 | { after(grammarAccess.getObjectTypeScopeAccess().getAlternatives_3()); } | ||
5226 | ) | ||
5227 | ; | ||
5228 | finally { | ||
5229 | restoreStackSize(stackSize); | ||
5230 | } | ||
5231 | |||
5232 | |||
5233 | rule__IntegerTypeScope__Group__0 | ||
5234 | @init { | ||
5235 | int stackSize = keepStackSize(); | ||
5236 | } | ||
5237 | : | ||
5238 | rule__IntegerTypeScope__Group__0__Impl | ||
5239 | rule__IntegerTypeScope__Group__1 | ||
5240 | ; | ||
5241 | finally { | ||
5242 | restoreStackSize(stackSize); | ||
5243 | } | ||
5244 | |||
5245 | rule__IntegerTypeScope__Group__0__Impl | ||
5246 | @init { | ||
5247 | int stackSize = keepStackSize(); | ||
5248 | } | ||
5249 | : | ||
5250 | ( | ||
5251 | { before(grammarAccess.getIntegerTypeScopeAccess().getNumberSignKeyword_0()); } | ||
5252 | '#' | ||
5253 | { after(grammarAccess.getIntegerTypeScopeAccess().getNumberSignKeyword_0()); } | ||
5254 | ) | ||
5255 | ; | ||
5256 | finally { | ||
5257 | restoreStackSize(stackSize); | ||
5258 | } | ||
5259 | |||
5260 | rule__IntegerTypeScope__Group__1 | ||
5261 | @init { | ||
5262 | int stackSize = keepStackSize(); | ||
5263 | } | ||
5264 | : | ||
5265 | rule__IntegerTypeScope__Group__1__Impl | ||
5266 | rule__IntegerTypeScope__Group__2 | ||
5267 | ; | ||
5268 | finally { | ||
5269 | restoreStackSize(stackSize); | ||
5270 | } | ||
5271 | |||
5272 | rule__IntegerTypeScope__Group__1__Impl | ||
5273 | @init { | ||
5274 | int stackSize = keepStackSize(); | ||
5275 | } | ||
5276 | : | ||
5277 | ( | ||
5278 | { before(grammarAccess.getIntegerTypeScopeAccess().getTypeAssignment_1()); } | ||
5279 | (rule__IntegerTypeScope__TypeAssignment_1) | ||
5280 | { after(grammarAccess.getIntegerTypeScopeAccess().getTypeAssignment_1()); } | ||
5281 | ) | ||
5282 | ; | ||
5283 | finally { | ||
5284 | restoreStackSize(stackSize); | ||
5285 | } | ||
5286 | |||
5287 | rule__IntegerTypeScope__Group__2 | ||
5288 | @init { | ||
5289 | int stackSize = keepStackSize(); | ||
5290 | } | ||
5291 | : | ||
5292 | rule__IntegerTypeScope__Group__2__Impl | ||
5293 | rule__IntegerTypeScope__Group__3 | ||
5294 | ; | ||
5295 | finally { | ||
5296 | restoreStackSize(stackSize); | ||
5297 | } | ||
5298 | |||
5299 | rule__IntegerTypeScope__Group__2__Impl | ||
5300 | @init { | ||
5301 | int stackSize = keepStackSize(); | ||
5302 | } | ||
5303 | : | ||
5304 | ( | ||
5305 | { before(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_2()); } | ||
5306 | (rule__IntegerTypeScope__Alternatives_2) | ||
5307 | { after(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_2()); } | ||
5308 | ) | ||
5309 | ; | ||
5310 | finally { | ||
5311 | restoreStackSize(stackSize); | ||
5312 | } | ||
5313 | |||
5314 | rule__IntegerTypeScope__Group__3 | ||
5315 | @init { | ||
5316 | int stackSize = keepStackSize(); | ||
5317 | } | ||
5318 | : | ||
5319 | rule__IntegerTypeScope__Group__3__Impl | ||
5320 | ; | ||
5321 | finally { | ||
5322 | restoreStackSize(stackSize); | ||
5323 | } | ||
5324 | |||
5325 | rule__IntegerTypeScope__Group__3__Impl | ||
5326 | @init { | ||
5327 | int stackSize = keepStackSize(); | ||
5328 | } | ||
5329 | : | ||
5330 | ( | ||
5331 | { before(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_3()); } | ||
5332 | (rule__IntegerTypeScope__Alternatives_3) | ||
5333 | { after(grammarAccess.getIntegerTypeScopeAccess().getAlternatives_3()); } | ||
5334 | ) | ||
5335 | ; | ||
5336 | finally { | ||
5337 | restoreStackSize(stackSize); | ||
5338 | } | ||
5339 | |||
5340 | |||
5341 | rule__RealTypeScope__Group__0 | ||
5342 | @init { | ||
5343 | int stackSize = keepStackSize(); | ||
5344 | } | ||
5345 | : | ||
5346 | rule__RealTypeScope__Group__0__Impl | ||
5347 | rule__RealTypeScope__Group__1 | ||
5348 | ; | ||
5349 | finally { | ||
5350 | restoreStackSize(stackSize); | ||
5351 | } | ||
5352 | |||
5353 | rule__RealTypeScope__Group__0__Impl | ||
5354 | @init { | ||
5355 | int stackSize = keepStackSize(); | ||
5356 | } | ||
5357 | : | ||
5358 | ( | ||
5359 | { before(grammarAccess.getRealTypeScopeAccess().getNumberSignKeyword_0()); } | ||
5360 | '#' | ||
5361 | { after(grammarAccess.getRealTypeScopeAccess().getNumberSignKeyword_0()); } | ||
5362 | ) | ||
5363 | ; | ||
5364 | finally { | ||
5365 | restoreStackSize(stackSize); | ||
5366 | } | ||
5367 | |||
5368 | rule__RealTypeScope__Group__1 | ||
5369 | @init { | ||
5370 | int stackSize = keepStackSize(); | ||
5371 | } | ||
5372 | : | ||
5373 | rule__RealTypeScope__Group__1__Impl | ||
5374 | rule__RealTypeScope__Group__2 | ||
5375 | ; | ||
5376 | finally { | ||
5377 | restoreStackSize(stackSize); | ||
5378 | } | ||
5379 | |||
5380 | rule__RealTypeScope__Group__1__Impl | ||
5381 | @init { | ||
5382 | int stackSize = keepStackSize(); | ||
5383 | } | ||
5384 | : | ||
5385 | ( | ||
5386 | { before(grammarAccess.getRealTypeScopeAccess().getTypeAssignment_1()); } | ||
5387 | (rule__RealTypeScope__TypeAssignment_1) | ||
5388 | { after(grammarAccess.getRealTypeScopeAccess().getTypeAssignment_1()); } | ||
5389 | ) | ||
5390 | ; | ||
5391 | finally { | ||
5392 | restoreStackSize(stackSize); | ||
5393 | } | ||
5394 | |||
5395 | rule__RealTypeScope__Group__2 | ||
5396 | @init { | ||
5397 | int stackSize = keepStackSize(); | ||
5398 | } | ||
5399 | : | ||
5400 | rule__RealTypeScope__Group__2__Impl | ||
5401 | rule__RealTypeScope__Group__3 | ||
5402 | ; | ||
5403 | finally { | ||
5404 | restoreStackSize(stackSize); | ||
5405 | } | ||
5406 | |||
5407 | rule__RealTypeScope__Group__2__Impl | ||
5408 | @init { | ||
5409 | int stackSize = keepStackSize(); | ||
5410 | } | ||
5411 | : | ||
5412 | ( | ||
5413 | { before(grammarAccess.getRealTypeScopeAccess().getAlternatives_2()); } | ||
5414 | (rule__RealTypeScope__Alternatives_2) | ||
5415 | { after(grammarAccess.getRealTypeScopeAccess().getAlternatives_2()); } | ||
5416 | ) | ||
5417 | ; | ||
5418 | finally { | ||
5419 | restoreStackSize(stackSize); | ||
5420 | } | ||
5421 | |||
5422 | rule__RealTypeScope__Group__3 | ||
5423 | @init { | ||
5424 | int stackSize = keepStackSize(); | ||
5425 | } | ||
5426 | : | ||
5427 | rule__RealTypeScope__Group__3__Impl | ||
5428 | ; | ||
5429 | finally { | ||
5430 | restoreStackSize(stackSize); | ||
5431 | } | ||
5432 | |||
5433 | rule__RealTypeScope__Group__3__Impl | ||
5434 | @init { | ||
5435 | int stackSize = keepStackSize(); | ||
5436 | } | ||
5437 | : | ||
5438 | ( | ||
5439 | { before(grammarAccess.getRealTypeScopeAccess().getAlternatives_3()); } | ||
5440 | (rule__RealTypeScope__Alternatives_3) | ||
5441 | { after(grammarAccess.getRealTypeScopeAccess().getAlternatives_3()); } | ||
5442 | ) | ||
5443 | ; | ||
5444 | finally { | ||
5445 | restoreStackSize(stackSize); | ||
5446 | } | ||
5447 | |||
5448 | |||
5449 | rule__StringTypeScope__Group__0 | ||
5450 | @init { | ||
5451 | int stackSize = keepStackSize(); | ||
5452 | } | ||
5453 | : | ||
5454 | rule__StringTypeScope__Group__0__Impl | ||
5455 | rule__StringTypeScope__Group__1 | ||
5456 | ; | ||
5457 | finally { | ||
5458 | restoreStackSize(stackSize); | ||
5459 | } | ||
5460 | |||
5461 | rule__StringTypeScope__Group__0__Impl | ||
5462 | @init { | ||
5463 | int stackSize = keepStackSize(); | ||
5464 | } | ||
5465 | : | ||
5466 | ( | ||
5467 | { before(grammarAccess.getStringTypeScopeAccess().getNumberSignKeyword_0()); } | ||
5468 | '#' | ||
5469 | { after(grammarAccess.getStringTypeScopeAccess().getNumberSignKeyword_0()); } | ||
5470 | ) | ||
5471 | ; | ||
5472 | finally { | ||
5473 | restoreStackSize(stackSize); | ||
5474 | } | ||
5475 | |||
5476 | rule__StringTypeScope__Group__1 | ||
5477 | @init { | ||
5478 | int stackSize = keepStackSize(); | ||
5479 | } | ||
5480 | : | ||
5481 | rule__StringTypeScope__Group__1__Impl | ||
5482 | rule__StringTypeScope__Group__2 | ||
5483 | ; | ||
5484 | finally { | ||
5485 | restoreStackSize(stackSize); | ||
5486 | } | ||
5487 | |||
5488 | rule__StringTypeScope__Group__1__Impl | ||
5489 | @init { | ||
5490 | int stackSize = keepStackSize(); | ||
5491 | } | ||
5492 | : | ||
5493 | ( | ||
5494 | { before(grammarAccess.getStringTypeScopeAccess().getTypeAssignment_1()); } | ||
5495 | (rule__StringTypeScope__TypeAssignment_1) | ||
5496 | { after(grammarAccess.getStringTypeScopeAccess().getTypeAssignment_1()); } | ||
5497 | ) | ||
5498 | ; | ||
5499 | finally { | ||
5500 | restoreStackSize(stackSize); | ||
5501 | } | ||
5502 | |||
5503 | rule__StringTypeScope__Group__2 | ||
5504 | @init { | ||
5505 | int stackSize = keepStackSize(); | ||
5506 | } | ||
5507 | : | ||
5508 | rule__StringTypeScope__Group__2__Impl | ||
5509 | rule__StringTypeScope__Group__3 | ||
5510 | ; | ||
5511 | finally { | ||
5512 | restoreStackSize(stackSize); | ||
5513 | } | ||
5514 | |||
5515 | rule__StringTypeScope__Group__2__Impl | ||
5516 | @init { | ||
5517 | int stackSize = keepStackSize(); | ||
5518 | } | ||
5519 | : | ||
5520 | ( | ||
5521 | { before(grammarAccess.getStringTypeScopeAccess().getAlternatives_2()); } | ||
5522 | (rule__StringTypeScope__Alternatives_2) | ||
5523 | { after(grammarAccess.getStringTypeScopeAccess().getAlternatives_2()); } | ||
5524 | ) | ||
5525 | ; | ||
5526 | finally { | ||
5527 | restoreStackSize(stackSize); | ||
5528 | } | ||
5529 | |||
5530 | rule__StringTypeScope__Group__3 | ||
5531 | @init { | ||
5532 | int stackSize = keepStackSize(); | ||
5533 | } | ||
5534 | : | ||
5535 | rule__StringTypeScope__Group__3__Impl | ||
5536 | ; | ||
5537 | finally { | ||
5538 | restoreStackSize(stackSize); | ||
5539 | } | ||
5540 | |||
5541 | rule__StringTypeScope__Group__3__Impl | ||
5542 | @init { | ||
5543 | int stackSize = keepStackSize(); | ||
5544 | } | ||
5545 | : | ||
5546 | ( | ||
5547 | { before(grammarAccess.getStringTypeScopeAccess().getAlternatives_3()); } | ||
5548 | (rule__StringTypeScope__Alternatives_3) | ||
5549 | { after(grammarAccess.getStringTypeScopeAccess().getAlternatives_3()); } | ||
5550 | ) | ||
5551 | ; | ||
5552 | finally { | ||
5553 | restoreStackSize(stackSize); | ||
5554 | } | ||
5555 | |||
5556 | |||
5557 | rule__ClassReference__Group__0 | ||
5558 | @init { | ||
5559 | int stackSize = keepStackSize(); | ||
5560 | } | ||
5561 | : | ||
5562 | rule__ClassReference__Group__0__Impl | ||
5563 | rule__ClassReference__Group__1 | ||
5564 | ; | ||
5565 | finally { | ||
5566 | restoreStackSize(stackSize); | ||
5567 | } | ||
5568 | |||
5569 | rule__ClassReference__Group__0__Impl | ||
5570 | @init { | ||
5571 | int stackSize = keepStackSize(); | ||
5572 | } | ||
5573 | : | ||
5574 | ( | ||
5575 | { before(grammarAccess.getClassReferenceAccess().getLessThanSignKeyword_0()); } | ||
5576 | '<' | ||
5577 | { after(grammarAccess.getClassReferenceAccess().getLessThanSignKeyword_0()); } | ||
5578 | ) | ||
5579 | ; | ||
5580 | finally { | ||
5581 | restoreStackSize(stackSize); | ||
5582 | } | ||
5583 | |||
5584 | rule__ClassReference__Group__1 | ||
5585 | @init { | ||
5586 | int stackSize = keepStackSize(); | ||
5587 | } | ||
5588 | : | ||
5589 | rule__ClassReference__Group__1__Impl | ||
5590 | rule__ClassReference__Group__2 | ||
5591 | ; | ||
5592 | finally { | ||
5593 | restoreStackSize(stackSize); | ||
5594 | } | ||
5595 | |||
5596 | rule__ClassReference__Group__1__Impl | ||
5597 | @init { | ||
5598 | int stackSize = keepStackSize(); | ||
5599 | } | ||
5600 | : | ||
5601 | ( | ||
5602 | { before(grammarAccess.getClassReferenceAccess().getElementAssignment_1()); } | ||
5603 | (rule__ClassReference__ElementAssignment_1) | ||
5604 | { after(grammarAccess.getClassReferenceAccess().getElementAssignment_1()); } | ||
5605 | ) | ||
5606 | ; | ||
5607 | finally { | ||
5608 | restoreStackSize(stackSize); | ||
5609 | } | ||
5610 | |||
5611 | rule__ClassReference__Group__2 | ||
5612 | @init { | ||
5613 | int stackSize = keepStackSize(); | ||
5614 | } | ||
5615 | : | ||
5616 | rule__ClassReference__Group__2__Impl | ||
5617 | ; | ||
5618 | finally { | ||
5619 | restoreStackSize(stackSize); | ||
5620 | } | ||
5621 | |||
5622 | rule__ClassReference__Group__2__Impl | ||
5623 | @init { | ||
5624 | int stackSize = keepStackSize(); | ||
5625 | } | ||
5626 | : | ||
5627 | ( | ||
5628 | { before(grammarAccess.getClassReferenceAccess().getGreaterThanSignKeyword_2()); } | ||
5629 | '>' | ||
5630 | { after(grammarAccess.getClassReferenceAccess().getGreaterThanSignKeyword_2()); } | ||
5631 | ) | ||
5632 | ; | ||
5633 | finally { | ||
5634 | restoreStackSize(stackSize); | ||
5635 | } | ||
5636 | |||
5637 | |||
5638 | rule__ObjectReference__Group__0 | ||
5639 | @init { | ||
5640 | int stackSize = keepStackSize(); | ||
5641 | } | ||
5642 | : | ||
5643 | rule__ObjectReference__Group__0__Impl | ||
5644 | rule__ObjectReference__Group__1 | ||
5645 | ; | ||
5646 | finally { | ||
5647 | restoreStackSize(stackSize); | ||
5648 | } | ||
5649 | |||
5650 | rule__ObjectReference__Group__0__Impl | ||
5651 | @init { | ||
5652 | int stackSize = keepStackSize(); | ||
5653 | } | ||
5654 | : | ||
5655 | ( | ||
5656 | { before(grammarAccess.getObjectReferenceAccess().getObjectReferenceAction_0()); } | ||
5657 | () | ||
5658 | { after(grammarAccess.getObjectReferenceAccess().getObjectReferenceAction_0()); } | ||
5659 | ) | ||
5660 | ; | ||
5661 | finally { | ||
5662 | restoreStackSize(stackSize); | ||
5663 | } | ||
5664 | |||
5665 | rule__ObjectReference__Group__1 | ||
5666 | @init { | ||
5667 | int stackSize = keepStackSize(); | ||
5668 | } | ||
5669 | : | ||
5670 | rule__ObjectReference__Group__1__Impl | ||
5671 | ; | ||
5672 | finally { | ||
5673 | restoreStackSize(stackSize); | ||
5674 | } | ||
5675 | |||
5676 | rule__ObjectReference__Group__1__Impl | ||
5677 | @init { | ||
5678 | int stackSize = keepStackSize(); | ||
5679 | } | ||
5680 | : | ||
5681 | ( | ||
5682 | { before(grammarAccess.getObjectReferenceAccess().getNodeKeyword_1()); } | ||
5683 | 'node' | ||
5684 | { after(grammarAccess.getObjectReferenceAccess().getNodeKeyword_1()); } | ||
5685 | ) | ||
5686 | ; | ||
5687 | finally { | ||
5688 | restoreStackSize(stackSize); | ||
5689 | } | ||
5690 | |||
5691 | |||
5692 | rule__IntegerReference__Group__0 | ||
5693 | @init { | ||
5694 | int stackSize = keepStackSize(); | ||
5695 | } | ||
5696 | : | ||
5697 | rule__IntegerReference__Group__0__Impl | ||
5698 | rule__IntegerReference__Group__1 | ||
5699 | ; | ||
5700 | finally { | ||
5701 | restoreStackSize(stackSize); | ||
5702 | } | ||
5703 | |||
5704 | rule__IntegerReference__Group__0__Impl | ||
5705 | @init { | ||
5706 | int stackSize = keepStackSize(); | ||
5707 | } | ||
5708 | : | ||
5709 | ( | ||
5710 | { before(grammarAccess.getIntegerReferenceAccess().getIntegerScopeAction_0()); } | ||
5711 | () | ||
5712 | { after(grammarAccess.getIntegerReferenceAccess().getIntegerScopeAction_0()); } | ||
5713 | ) | ||
5714 | ; | ||
5715 | finally { | ||
5716 | restoreStackSize(stackSize); | ||
5717 | } | ||
5718 | |||
5719 | rule__IntegerReference__Group__1 | ||
5720 | @init { | ||
5721 | int stackSize = keepStackSize(); | ||
5722 | } | ||
5723 | : | ||
5724 | rule__IntegerReference__Group__1__Impl | ||
5725 | ; | ||
5726 | finally { | ||
5727 | restoreStackSize(stackSize); | ||
5728 | } | ||
5729 | |||
5730 | rule__IntegerReference__Group__1__Impl | ||
5731 | @init { | ||
5732 | int stackSize = keepStackSize(); | ||
5733 | } | ||
5734 | : | ||
5735 | ( | ||
5736 | { before(grammarAccess.getIntegerReferenceAccess().getIntKeyword_1()); } | ||
5737 | 'int' | ||
5738 | { after(grammarAccess.getIntegerReferenceAccess().getIntKeyword_1()); } | ||
5739 | ) | ||
5740 | ; | ||
5741 | finally { | ||
5742 | restoreStackSize(stackSize); | ||
5743 | } | ||
5744 | |||
5745 | |||
5746 | rule__RealReference__Group__0 | ||
5747 | @init { | ||
5748 | int stackSize = keepStackSize(); | ||
5749 | } | ||
5750 | : | ||
5751 | rule__RealReference__Group__0__Impl | ||
5752 | rule__RealReference__Group__1 | ||
5753 | ; | ||
5754 | finally { | ||
5755 | restoreStackSize(stackSize); | ||
5756 | } | ||
5757 | |||
5758 | rule__RealReference__Group__0__Impl | ||
5759 | @init { | ||
5760 | int stackSize = keepStackSize(); | ||
5761 | } | ||
5762 | : | ||
5763 | ( | ||
5764 | { before(grammarAccess.getRealReferenceAccess().getRealScopeAction_0()); } | ||
5765 | () | ||
5766 | { after(grammarAccess.getRealReferenceAccess().getRealScopeAction_0()); } | ||
5767 | ) | ||
5768 | ; | ||
5769 | finally { | ||
5770 | restoreStackSize(stackSize); | ||
5771 | } | ||
5772 | |||
5773 | rule__RealReference__Group__1 | ||
5774 | @init { | ||
5775 | int stackSize = keepStackSize(); | ||
5776 | } | ||
5777 | : | ||
5778 | rule__RealReference__Group__1__Impl | ||
5779 | ; | ||
5780 | finally { | ||
5781 | restoreStackSize(stackSize); | ||
5782 | } | ||
5783 | |||
5784 | rule__RealReference__Group__1__Impl | ||
5785 | @init { | ||
5786 | int stackSize = keepStackSize(); | ||
5787 | } | ||
5788 | : | ||
5789 | ( | ||
5790 | { before(grammarAccess.getRealReferenceAccess().getRealKeyword_1()); } | ||
5791 | 'real' | ||
5792 | { after(grammarAccess.getRealReferenceAccess().getRealKeyword_1()); } | ||
5793 | ) | ||
5794 | ; | ||
5795 | finally { | ||
5796 | restoreStackSize(stackSize); | ||
5797 | } | ||
5798 | |||
5799 | |||
5800 | rule__StringReference__Group__0 | ||
5801 | @init { | ||
5802 | int stackSize = keepStackSize(); | ||
5803 | } | ||
5804 | : | ||
5805 | rule__StringReference__Group__0__Impl | ||
5806 | rule__StringReference__Group__1 | ||
5807 | ; | ||
5808 | finally { | ||
5809 | restoreStackSize(stackSize); | ||
5810 | } | ||
5811 | |||
5812 | rule__StringReference__Group__0__Impl | ||
5813 | @init { | ||
5814 | int stackSize = keepStackSize(); | ||
5815 | } | ||
5816 | : | ||
5817 | ( | ||
5818 | { before(grammarAccess.getStringReferenceAccess().getStringScopeAction_0()); } | ||
5819 | () | ||
5820 | { after(grammarAccess.getStringReferenceAccess().getStringScopeAction_0()); } | ||
5821 | ) | ||
5822 | ; | ||
5823 | finally { | ||
5824 | restoreStackSize(stackSize); | ||
5825 | } | ||
5826 | |||
5827 | rule__StringReference__Group__1 | ||
5828 | @init { | ||
5829 | int stackSize = keepStackSize(); | ||
5830 | } | ||
5831 | : | ||
5832 | rule__StringReference__Group__1__Impl | ||
5833 | ; | ||
5834 | finally { | ||
5835 | restoreStackSize(stackSize); | ||
5836 | } | ||
5837 | |||
5838 | rule__StringReference__Group__1__Impl | ||
5839 | @init { | ||
5840 | int stackSize = keepStackSize(); | ||
5841 | } | ||
5842 | : | ||
5843 | ( | ||
5844 | { before(grammarAccess.getStringReferenceAccess().getStringKeyword_1()); } | ||
5845 | 'string' | ||
5846 | { after(grammarAccess.getStringReferenceAccess().getStringKeyword_1()); } | ||
5847 | ) | ||
5848 | ; | ||
5849 | finally { | ||
5850 | restoreStackSize(stackSize); | ||
5851 | } | ||
5852 | |||
5853 | |||
5854 | rule__IntervallNumber__Group__0 | ||
5855 | @init { | ||
5856 | int stackSize = keepStackSize(); | ||
5857 | } | ||
5858 | : | ||
5859 | rule__IntervallNumber__Group__0__Impl | ||
5860 | rule__IntervallNumber__Group__1 | ||
5861 | ; | ||
5862 | finally { | ||
5863 | restoreStackSize(stackSize); | ||
5864 | } | ||
5865 | |||
5866 | rule__IntervallNumber__Group__0__Impl | ||
5867 | @init { | ||
5868 | int stackSize = keepStackSize(); | ||
5869 | } | ||
5870 | : | ||
5871 | ( | ||
5872 | { before(grammarAccess.getIntervallNumberAccess().getMinAssignment_0()); } | ||
5873 | (rule__IntervallNumber__MinAssignment_0) | ||
5874 | { after(grammarAccess.getIntervallNumberAccess().getMinAssignment_0()); } | ||
5875 | ) | ||
5876 | ; | ||
5877 | finally { | ||
5878 | restoreStackSize(stackSize); | ||
5879 | } | ||
5880 | |||
5881 | rule__IntervallNumber__Group__1 | ||
5882 | @init { | ||
5883 | int stackSize = keepStackSize(); | ||
5884 | } | ||
5885 | : | ||
5886 | rule__IntervallNumber__Group__1__Impl | ||
5887 | rule__IntervallNumber__Group__2 | ||
5888 | ; | ||
5889 | finally { | ||
5890 | restoreStackSize(stackSize); | ||
5891 | } | ||
5892 | |||
5893 | rule__IntervallNumber__Group__1__Impl | ||
5894 | @init { | ||
5895 | int stackSize = keepStackSize(); | ||
5896 | } | ||
5897 | : | ||
5898 | ( | ||
5899 | { before(grammarAccess.getIntervallNumberAccess().getFullStopFullStopKeyword_1()); } | ||
5900 | '..' | ||
5901 | { after(grammarAccess.getIntervallNumberAccess().getFullStopFullStopKeyword_1()); } | ||
5902 | ) | ||
5903 | ; | ||
5904 | finally { | ||
5905 | restoreStackSize(stackSize); | ||
5906 | } | ||
5907 | |||
5908 | rule__IntervallNumber__Group__2 | ||
5909 | @init { | ||
5910 | int stackSize = keepStackSize(); | ||
5911 | } | ||
5912 | : | ||
5913 | rule__IntervallNumber__Group__2__Impl | ||
5914 | ; | ||
5915 | finally { | ||
5916 | restoreStackSize(stackSize); | ||
5917 | } | ||
5918 | |||
5919 | rule__IntervallNumber__Group__2__Impl | ||
5920 | @init { | ||
5921 | int stackSize = keepStackSize(); | ||
5922 | } | ||
5923 | : | ||
5924 | ( | ||
5925 | { before(grammarAccess.getIntervallNumberAccess().getAlternatives_2()); } | ||
5926 | (rule__IntervallNumber__Alternatives_2) | ||
5927 | { after(grammarAccess.getIntervallNumberAccess().getAlternatives_2()); } | ||
5928 | ) | ||
5929 | ; | ||
5930 | finally { | ||
5931 | restoreStackSize(stackSize); | ||
5932 | } | ||
5933 | |||
5934 | |||
5935 | rule__IntEnumberation__Group__0 | ||
5936 | @init { | ||
5937 | int stackSize = keepStackSize(); | ||
5938 | } | ||
5939 | : | ||
5940 | rule__IntEnumberation__Group__0__Impl | ||
5941 | rule__IntEnumberation__Group__1 | ||
5942 | ; | ||
5943 | finally { | ||
5944 | restoreStackSize(stackSize); | ||
5945 | } | ||
5946 | |||
5947 | rule__IntEnumberation__Group__0__Impl | ||
5948 | @init { | ||
5949 | int stackSize = keepStackSize(); | ||
5950 | } | ||
5951 | : | ||
5952 | ( | ||
5953 | { before(grammarAccess.getIntEnumberationAccess().getIntEnumberationAction_0()); } | ||
5954 | () | ||
5955 | { after(grammarAccess.getIntEnumberationAccess().getIntEnumberationAction_0()); } | ||
5956 | ) | ||
5957 | ; | ||
5958 | finally { | ||
5959 | restoreStackSize(stackSize); | ||
5960 | } | ||
5961 | |||
5962 | rule__IntEnumberation__Group__1 | ||
5963 | @init { | ||
5964 | int stackSize = keepStackSize(); | ||
5965 | } | ||
5966 | : | ||
5967 | rule__IntEnumberation__Group__1__Impl | ||
5968 | rule__IntEnumberation__Group__2 | ||
5969 | ; | ||
5970 | finally { | ||
5971 | restoreStackSize(stackSize); | ||
5972 | } | ||
5973 | |||
5974 | rule__IntEnumberation__Group__1__Impl | ||
5975 | @init { | ||
5976 | int stackSize = keepStackSize(); | ||
5977 | } | ||
5978 | : | ||
5979 | ( | ||
5980 | { before(grammarAccess.getIntEnumberationAccess().getLeftCurlyBracketKeyword_1()); } | ||
5981 | '{' | ||
5982 | { after(grammarAccess.getIntEnumberationAccess().getLeftCurlyBracketKeyword_1()); } | ||
5983 | ) | ||
5984 | ; | ||
5985 | finally { | ||
5986 | restoreStackSize(stackSize); | ||
5987 | } | ||
5988 | |||
5989 | rule__IntEnumberation__Group__2 | ||
5990 | @init { | ||
5991 | int stackSize = keepStackSize(); | ||
5992 | } | ||
5993 | : | ||
5994 | rule__IntEnumberation__Group__2__Impl | ||
5995 | rule__IntEnumberation__Group__3 | ||
5996 | ; | ||
5997 | finally { | ||
5998 | restoreStackSize(stackSize); | ||
5999 | } | ||
6000 | |||
6001 | rule__IntEnumberation__Group__2__Impl | ||
6002 | @init { | ||
6003 | int stackSize = keepStackSize(); | ||
6004 | } | ||
6005 | : | ||
6006 | ( | ||
6007 | { before(grammarAccess.getIntEnumberationAccess().getGroup_2()); } | ||
6008 | (rule__IntEnumberation__Group_2__0)? | ||
6009 | { after(grammarAccess.getIntEnumberationAccess().getGroup_2()); } | ||
6010 | ) | ||
6011 | ; | ||
6012 | finally { | ||
6013 | restoreStackSize(stackSize); | ||
6014 | } | ||
6015 | |||
6016 | rule__IntEnumberation__Group__3 | ||
6017 | @init { | ||
6018 | int stackSize = keepStackSize(); | ||
6019 | } | ||
6020 | : | ||
6021 | rule__IntEnumberation__Group__3__Impl | ||
6022 | ; | ||
6023 | finally { | ||
6024 | restoreStackSize(stackSize); | ||
6025 | } | ||
6026 | |||
6027 | rule__IntEnumberation__Group__3__Impl | ||
6028 | @init { | ||
6029 | int stackSize = keepStackSize(); | ||
6030 | } | ||
6031 | : | ||
6032 | ( | ||
6033 | { before(grammarAccess.getIntEnumberationAccess().getRightCurlyBracketKeyword_3()); } | ||
6034 | '}' | ||
6035 | { after(grammarAccess.getIntEnumberationAccess().getRightCurlyBracketKeyword_3()); } | ||
6036 | ) | ||
6037 | ; | ||
6038 | finally { | ||
6039 | restoreStackSize(stackSize); | ||
6040 | } | ||
6041 | |||
6042 | |||
6043 | rule__IntEnumberation__Group_2__0 | ||
6044 | @init { | ||
6045 | int stackSize = keepStackSize(); | ||
6046 | } | ||
6047 | : | ||
6048 | rule__IntEnumberation__Group_2__0__Impl | ||
6049 | rule__IntEnumberation__Group_2__1 | ||
6050 | ; | ||
6051 | finally { | ||
6052 | restoreStackSize(stackSize); | ||
6053 | } | ||
6054 | |||
6055 | rule__IntEnumberation__Group_2__0__Impl | ||
6056 | @init { | ||
6057 | int stackSize = keepStackSize(); | ||
6058 | } | ||
6059 | : | ||
6060 | ( | ||
6061 | { before(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_0()); } | ||
6062 | (rule__IntEnumberation__EntryAssignment_2_0) | ||
6063 | { after(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_0()); } | ||
6064 | ) | ||
6065 | ; | ||
6066 | finally { | ||
6067 | restoreStackSize(stackSize); | ||
6068 | } | ||
6069 | |||
6070 | rule__IntEnumberation__Group_2__1 | ||
6071 | @init { | ||
6072 | int stackSize = keepStackSize(); | ||
6073 | } | ||
6074 | : | ||
6075 | rule__IntEnumberation__Group_2__1__Impl | ||
6076 | ; | ||
6077 | finally { | ||
6078 | restoreStackSize(stackSize); | ||
6079 | } | ||
6080 | |||
6081 | rule__IntEnumberation__Group_2__1__Impl | ||
6082 | @init { | ||
6083 | int stackSize = keepStackSize(); | ||
6084 | } | ||
6085 | : | ||
6086 | ( | ||
6087 | { before(grammarAccess.getIntEnumberationAccess().getGroup_2_1()); } | ||
6088 | (rule__IntEnumberation__Group_2_1__0)* | ||
6089 | { after(grammarAccess.getIntEnumberationAccess().getGroup_2_1()); } | ||
6090 | ) | ||
6091 | ; | ||
6092 | finally { | ||
6093 | restoreStackSize(stackSize); | ||
6094 | } | ||
6095 | |||
6096 | |||
6097 | rule__IntEnumberation__Group_2_1__0 | ||
6098 | @init { | ||
6099 | int stackSize = keepStackSize(); | ||
6100 | } | ||
6101 | : | ||
6102 | rule__IntEnumberation__Group_2_1__0__Impl | ||
6103 | rule__IntEnumberation__Group_2_1__1 | ||
6104 | ; | ||
6105 | finally { | ||
6106 | restoreStackSize(stackSize); | ||
6107 | } | ||
6108 | |||
6109 | rule__IntEnumberation__Group_2_1__0__Impl | ||
6110 | @init { | ||
6111 | int stackSize = keepStackSize(); | ||
6112 | } | ||
6113 | : | ||
6114 | ( | ||
6115 | { before(grammarAccess.getIntEnumberationAccess().getCommaKeyword_2_1_0()); } | ||
6116 | ',' | ||
6117 | { after(grammarAccess.getIntEnumberationAccess().getCommaKeyword_2_1_0()); } | ||
6118 | ) | ||
6119 | ; | ||
6120 | finally { | ||
6121 | restoreStackSize(stackSize); | ||
6122 | } | ||
6123 | |||
6124 | rule__IntEnumberation__Group_2_1__1 | ||
6125 | @init { | ||
6126 | int stackSize = keepStackSize(); | ||
6127 | } | ||
6128 | : | ||
6129 | rule__IntEnumberation__Group_2_1__1__Impl | ||
6130 | ; | ||
6131 | finally { | ||
6132 | restoreStackSize(stackSize); | ||
6133 | } | ||
6134 | |||
6135 | rule__IntEnumberation__Group_2_1__1__Impl | ||
6136 | @init { | ||
6137 | int stackSize = keepStackSize(); | ||
6138 | } | ||
6139 | : | ||
6140 | ( | ||
6141 | { before(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_1_1()); } | ||
6142 | (rule__IntEnumberation__EntryAssignment_2_1_1) | ||
6143 | { after(grammarAccess.getIntEnumberationAccess().getEntryAssignment_2_1_1()); } | ||
6144 | ) | ||
6145 | ; | ||
6146 | finally { | ||
6147 | restoreStackSize(stackSize); | ||
6148 | } | ||
6149 | |||
6150 | |||
6151 | rule__RealEnumeration__Group__0 | ||
6152 | @init { | ||
6153 | int stackSize = keepStackSize(); | ||
6154 | } | ||
6155 | : | ||
6156 | rule__RealEnumeration__Group__0__Impl | ||
6157 | rule__RealEnumeration__Group__1 | ||
6158 | ; | ||
6159 | finally { | ||
6160 | restoreStackSize(stackSize); | ||
6161 | } | ||
6162 | |||
6163 | rule__RealEnumeration__Group__0__Impl | ||
6164 | @init { | ||
6165 | int stackSize = keepStackSize(); | ||
6166 | } | ||
6167 | : | ||
6168 | ( | ||
6169 | { before(grammarAccess.getRealEnumerationAccess().getRealEnumerationAction_0()); } | ||
6170 | () | ||
6171 | { after(grammarAccess.getRealEnumerationAccess().getRealEnumerationAction_0()); } | ||
6172 | ) | ||
6173 | ; | ||
6174 | finally { | ||
6175 | restoreStackSize(stackSize); | ||
6176 | } | ||
6177 | |||
6178 | rule__RealEnumeration__Group__1 | ||
6179 | @init { | ||
6180 | int stackSize = keepStackSize(); | ||
6181 | } | ||
6182 | : | ||
6183 | rule__RealEnumeration__Group__1__Impl | ||
6184 | rule__RealEnumeration__Group__2 | ||
6185 | ; | ||
6186 | finally { | ||
6187 | restoreStackSize(stackSize); | ||
6188 | } | ||
6189 | |||
6190 | rule__RealEnumeration__Group__1__Impl | ||
6191 | @init { | ||
6192 | int stackSize = keepStackSize(); | ||
6193 | } | ||
6194 | : | ||
6195 | ( | ||
6196 | { before(grammarAccess.getRealEnumerationAccess().getLeftCurlyBracketKeyword_1()); } | ||
6197 | '{' | ||
6198 | { after(grammarAccess.getRealEnumerationAccess().getLeftCurlyBracketKeyword_1()); } | ||
6199 | ) | ||
6200 | ; | ||
6201 | finally { | ||
6202 | restoreStackSize(stackSize); | ||
6203 | } | ||
6204 | |||
6205 | rule__RealEnumeration__Group__2 | ||
6206 | @init { | ||
6207 | int stackSize = keepStackSize(); | ||
6208 | } | ||
6209 | : | ||
6210 | rule__RealEnumeration__Group__2__Impl | ||
6211 | rule__RealEnumeration__Group__3 | ||
6212 | ; | ||
6213 | finally { | ||
6214 | restoreStackSize(stackSize); | ||
6215 | } | ||
6216 | |||
6217 | rule__RealEnumeration__Group__2__Impl | ||
6218 | @init { | ||
6219 | int stackSize = keepStackSize(); | ||
6220 | } | ||
6221 | : | ||
6222 | ( | ||
6223 | { before(grammarAccess.getRealEnumerationAccess().getGroup_2()); } | ||
6224 | (rule__RealEnumeration__Group_2__0)? | ||
6225 | { after(grammarAccess.getRealEnumerationAccess().getGroup_2()); } | ||
6226 | ) | ||
6227 | ; | ||
6228 | finally { | ||
6229 | restoreStackSize(stackSize); | ||
6230 | } | ||
6231 | |||
6232 | rule__RealEnumeration__Group__3 | ||
6233 | @init { | ||
6234 | int stackSize = keepStackSize(); | ||
6235 | } | ||
6236 | : | ||
6237 | rule__RealEnumeration__Group__3__Impl | ||
6238 | ; | ||
6239 | finally { | ||
6240 | restoreStackSize(stackSize); | ||
6241 | } | ||
6242 | |||
6243 | rule__RealEnumeration__Group__3__Impl | ||
6244 | @init { | ||
6245 | int stackSize = keepStackSize(); | ||
6246 | } | ||
6247 | : | ||
6248 | ( | ||
6249 | { before(grammarAccess.getRealEnumerationAccess().getRightCurlyBracketKeyword_3()); } | ||
6250 | '}' | ||
6251 | { after(grammarAccess.getRealEnumerationAccess().getRightCurlyBracketKeyword_3()); } | ||
6252 | ) | ||
6253 | ; | ||
6254 | finally { | ||
6255 | restoreStackSize(stackSize); | ||
6256 | } | ||
6257 | |||
6258 | |||
6259 | rule__RealEnumeration__Group_2__0 | ||
6260 | @init { | ||
6261 | int stackSize = keepStackSize(); | ||
6262 | } | ||
6263 | : | ||
6264 | rule__RealEnumeration__Group_2__0__Impl | ||
6265 | rule__RealEnumeration__Group_2__1 | ||
6266 | ; | ||
6267 | finally { | ||
6268 | restoreStackSize(stackSize); | ||
6269 | } | ||
6270 | |||
6271 | rule__RealEnumeration__Group_2__0__Impl | ||
6272 | @init { | ||
6273 | int stackSize = keepStackSize(); | ||
6274 | } | ||
6275 | : | ||
6276 | ( | ||
6277 | { before(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_0()); } | ||
6278 | (rule__RealEnumeration__EntryAssignment_2_0) | ||
6279 | { after(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_0()); } | ||
6280 | ) | ||
6281 | ; | ||
6282 | finally { | ||
6283 | restoreStackSize(stackSize); | ||
6284 | } | ||
6285 | |||
6286 | rule__RealEnumeration__Group_2__1 | ||
6287 | @init { | ||
6288 | int stackSize = keepStackSize(); | ||
6289 | } | ||
6290 | : | ||
6291 | rule__RealEnumeration__Group_2__1__Impl | ||
6292 | ; | ||
6293 | finally { | ||
6294 | restoreStackSize(stackSize); | ||
6295 | } | ||
6296 | |||
6297 | rule__RealEnumeration__Group_2__1__Impl | ||
6298 | @init { | ||
6299 | int stackSize = keepStackSize(); | ||
6300 | } | ||
6301 | : | ||
6302 | ( | ||
6303 | { before(grammarAccess.getRealEnumerationAccess().getGroup_2_1()); } | ||
6304 | (rule__RealEnumeration__Group_2_1__0)* | ||
6305 | { after(grammarAccess.getRealEnumerationAccess().getGroup_2_1()); } | ||
6306 | ) | ||
6307 | ; | ||
6308 | finally { | ||
6309 | restoreStackSize(stackSize); | ||
6310 | } | ||
6311 | |||
6312 | |||
6313 | rule__RealEnumeration__Group_2_1__0 | ||
6314 | @init { | ||
6315 | int stackSize = keepStackSize(); | ||
6316 | } | ||
6317 | : | ||
6318 | rule__RealEnumeration__Group_2_1__0__Impl | ||
6319 | rule__RealEnumeration__Group_2_1__1 | ||
6320 | ; | ||
6321 | finally { | ||
6322 | restoreStackSize(stackSize); | ||
6323 | } | ||
6324 | |||
6325 | rule__RealEnumeration__Group_2_1__0__Impl | ||
6326 | @init { | ||
6327 | int stackSize = keepStackSize(); | ||
6328 | } | ||
6329 | : | ||
6330 | ( | ||
6331 | { before(grammarAccess.getRealEnumerationAccess().getCommaKeyword_2_1_0()); } | ||
6332 | ',' | ||
6333 | { after(grammarAccess.getRealEnumerationAccess().getCommaKeyword_2_1_0()); } | ||
6334 | ) | ||
6335 | ; | ||
6336 | finally { | ||
6337 | restoreStackSize(stackSize); | ||
6338 | } | ||
6339 | |||
6340 | rule__RealEnumeration__Group_2_1__1 | ||
6341 | @init { | ||
6342 | int stackSize = keepStackSize(); | ||
6343 | } | ||
6344 | : | ||
6345 | rule__RealEnumeration__Group_2_1__1__Impl | ||
6346 | ; | ||
6347 | finally { | ||
6348 | restoreStackSize(stackSize); | ||
6349 | } | ||
6350 | |||
6351 | rule__RealEnumeration__Group_2_1__1__Impl | ||
6352 | @init { | ||
6353 | int stackSize = keepStackSize(); | ||
6354 | } | ||
6355 | : | ||
6356 | ( | ||
6357 | { before(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_1_1()); } | ||
6358 | (rule__RealEnumeration__EntryAssignment_2_1_1) | ||
6359 | { after(grammarAccess.getRealEnumerationAccess().getEntryAssignment_2_1_1()); } | ||
6360 | ) | ||
6361 | ; | ||
6362 | finally { | ||
6363 | restoreStackSize(stackSize); | ||
6364 | } | ||
6365 | |||
6366 | |||
6367 | rule__StringEnumeration__Group__0 | ||
6368 | @init { | ||
6369 | int stackSize = keepStackSize(); | ||
6370 | } | ||
6371 | : | ||
6372 | rule__StringEnumeration__Group__0__Impl | ||
6373 | rule__StringEnumeration__Group__1 | ||
6374 | ; | ||
6375 | finally { | ||
6376 | restoreStackSize(stackSize); | ||
6377 | } | ||
6378 | |||
6379 | rule__StringEnumeration__Group__0__Impl | ||
6380 | @init { | ||
6381 | int stackSize = keepStackSize(); | ||
6382 | } | ||
6383 | : | ||
6384 | ( | ||
6385 | { before(grammarAccess.getStringEnumerationAccess().getStringEnumerationAction_0()); } | ||
6386 | () | ||
6387 | { after(grammarAccess.getStringEnumerationAccess().getStringEnumerationAction_0()); } | ||
6388 | ) | ||
6389 | ; | ||
6390 | finally { | ||
6391 | restoreStackSize(stackSize); | ||
6392 | } | ||
6393 | |||
6394 | rule__StringEnumeration__Group__1 | ||
6395 | @init { | ||
6396 | int stackSize = keepStackSize(); | ||
6397 | } | ||
6398 | : | ||
6399 | rule__StringEnumeration__Group__1__Impl | ||
6400 | rule__StringEnumeration__Group__2 | ||
6401 | ; | ||
6402 | finally { | ||
6403 | restoreStackSize(stackSize); | ||
6404 | } | ||
6405 | |||
6406 | rule__StringEnumeration__Group__1__Impl | ||
6407 | @init { | ||
6408 | int stackSize = keepStackSize(); | ||
6409 | } | ||
6410 | : | ||
6411 | ( | ||
6412 | { before(grammarAccess.getStringEnumerationAccess().getLeftCurlyBracketKeyword_1()); } | ||
6413 | '{' | ||
6414 | { after(grammarAccess.getStringEnumerationAccess().getLeftCurlyBracketKeyword_1()); } | ||
6415 | ) | ||
6416 | ; | ||
6417 | finally { | ||
6418 | restoreStackSize(stackSize); | ||
6419 | } | ||
6420 | |||
6421 | rule__StringEnumeration__Group__2 | ||
6422 | @init { | ||
6423 | int stackSize = keepStackSize(); | ||
6424 | } | ||
6425 | : | ||
6426 | rule__StringEnumeration__Group__2__Impl | ||
6427 | rule__StringEnumeration__Group__3 | ||
6428 | ; | ||
6429 | finally { | ||
6430 | restoreStackSize(stackSize); | ||
6431 | } | ||
6432 | |||
6433 | rule__StringEnumeration__Group__2__Impl | ||
6434 | @init { | ||
6435 | int stackSize = keepStackSize(); | ||
6436 | } | ||
6437 | : | ||
6438 | ( | ||
6439 | { before(grammarAccess.getStringEnumerationAccess().getGroup_2()); } | ||
6440 | (rule__StringEnumeration__Group_2__0)? | ||
6441 | { after(grammarAccess.getStringEnumerationAccess().getGroup_2()); } | ||
6442 | ) | ||
6443 | ; | ||
6444 | finally { | ||
6445 | restoreStackSize(stackSize); | ||
6446 | } | ||
6447 | |||
6448 | rule__StringEnumeration__Group__3 | ||
6449 | @init { | ||
6450 | int stackSize = keepStackSize(); | ||
6451 | } | ||
6452 | : | ||
6453 | rule__StringEnumeration__Group__3__Impl | ||
6454 | ; | ||
6455 | finally { | ||
6456 | restoreStackSize(stackSize); | ||
6457 | } | ||
6458 | |||
6459 | rule__StringEnumeration__Group__3__Impl | ||
6460 | @init { | ||
6461 | int stackSize = keepStackSize(); | ||
6462 | } | ||
6463 | : | ||
6464 | ( | ||
6465 | { before(grammarAccess.getStringEnumerationAccess().getRightCurlyBracketKeyword_3()); } | ||
6466 | '}' | ||
6467 | { after(grammarAccess.getStringEnumerationAccess().getRightCurlyBracketKeyword_3()); } | ||
6468 | ) | ||
6469 | ; | ||
6470 | finally { | ||
6471 | restoreStackSize(stackSize); | ||
6472 | } | ||
6473 | |||
6474 | |||
6475 | rule__StringEnumeration__Group_2__0 | ||
6476 | @init { | ||
6477 | int stackSize = keepStackSize(); | ||
6478 | } | ||
6479 | : | ||
6480 | rule__StringEnumeration__Group_2__0__Impl | ||
6481 | rule__StringEnumeration__Group_2__1 | ||
6482 | ; | ||
6483 | finally { | ||
6484 | restoreStackSize(stackSize); | ||
6485 | } | ||
6486 | |||
6487 | rule__StringEnumeration__Group_2__0__Impl | ||
6488 | @init { | ||
6489 | int stackSize = keepStackSize(); | ||
6490 | } | ||
6491 | : | ||
6492 | ( | ||
6493 | { before(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_0()); } | ||
6494 | (rule__StringEnumeration__EntryAssignment_2_0) | ||
6495 | { after(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_0()); } | ||
6496 | ) | ||
6497 | ; | ||
6498 | finally { | ||
6499 | restoreStackSize(stackSize); | ||
6500 | } | ||
6501 | |||
6502 | rule__StringEnumeration__Group_2__1 | ||
6503 | @init { | ||
6504 | int stackSize = keepStackSize(); | ||
6505 | } | ||
6506 | : | ||
6507 | rule__StringEnumeration__Group_2__1__Impl | ||
6508 | ; | ||
6509 | finally { | ||
6510 | restoreStackSize(stackSize); | ||
6511 | } | ||
6512 | |||
6513 | rule__StringEnumeration__Group_2__1__Impl | ||
6514 | @init { | ||
6515 | int stackSize = keepStackSize(); | ||
6516 | } | ||
6517 | : | ||
6518 | ( | ||
6519 | { before(grammarAccess.getStringEnumerationAccess().getGroup_2_1()); } | ||
6520 | (rule__StringEnumeration__Group_2_1__0)* | ||
6521 | { after(grammarAccess.getStringEnumerationAccess().getGroup_2_1()); } | ||
6522 | ) | ||
6523 | ; | ||
6524 | finally { | ||
6525 | restoreStackSize(stackSize); | ||
6526 | } | ||
6527 | |||
6528 | |||
6529 | rule__StringEnumeration__Group_2_1__0 | ||
6530 | @init { | ||
6531 | int stackSize = keepStackSize(); | ||
6532 | } | ||
6533 | : | ||
6534 | rule__StringEnumeration__Group_2_1__0__Impl | ||
6535 | rule__StringEnumeration__Group_2_1__1 | ||
6536 | ; | ||
6537 | finally { | ||
6538 | restoreStackSize(stackSize); | ||
6539 | } | ||
6540 | |||
6541 | rule__StringEnumeration__Group_2_1__0__Impl | ||
6542 | @init { | ||
6543 | int stackSize = keepStackSize(); | ||
6544 | } | ||
6545 | : | ||
6546 | ( | ||
6547 | { before(grammarAccess.getStringEnumerationAccess().getCommaKeyword_2_1_0()); } | ||
6548 | ',' | ||
6549 | { after(grammarAccess.getStringEnumerationAccess().getCommaKeyword_2_1_0()); } | ||
6550 | ) | ||
6551 | ; | ||
6552 | finally { | ||
6553 | restoreStackSize(stackSize); | ||
6554 | } | ||
6555 | |||
6556 | rule__StringEnumeration__Group_2_1__1 | ||
6557 | @init { | ||
6558 | int stackSize = keepStackSize(); | ||
6559 | } | ||
6560 | : | ||
6561 | rule__StringEnumeration__Group_2_1__1__Impl | ||
6562 | ; | ||
6563 | finally { | ||
6564 | restoreStackSize(stackSize); | ||
6565 | } | ||
6566 | |||
6567 | rule__StringEnumeration__Group_2_1__1__Impl | ||
6568 | @init { | ||
6569 | int stackSize = keepStackSize(); | ||
6570 | } | ||
6571 | : | ||
6572 | ( | ||
6573 | { before(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_1_1()); } | ||
6574 | (rule__StringEnumeration__EntryAssignment_2_1_1) | ||
6575 | { after(grammarAccess.getStringEnumerationAccess().getEntryAssignment_2_1_1()); } | ||
6576 | ) | ||
6577 | ; | ||
6578 | finally { | ||
6579 | restoreStackSize(stackSize); | ||
6580 | } | ||
6581 | |||
6582 | |||
6583 | rule__ScopeDeclaration__Group__0 | ||
6584 | @init { | ||
6585 | int stackSize = keepStackSize(); | ||
6586 | } | ||
6587 | : | ||
6588 | rule__ScopeDeclaration__Group__0__Impl | ||
6589 | rule__ScopeDeclaration__Group__1 | ||
6590 | ; | ||
6591 | finally { | ||
6592 | restoreStackSize(stackSize); | ||
6593 | } | ||
6594 | |||
6595 | rule__ScopeDeclaration__Group__0__Impl | ||
6596 | @init { | ||
6597 | int stackSize = keepStackSize(); | ||
6598 | } | ||
6599 | : | ||
6600 | ( | ||
6601 | { before(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); } | ||
6602 | 'scope' | ||
6603 | { after(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); } | ||
6604 | ) | ||
6605 | ; | ||
6606 | finally { | ||
6607 | restoreStackSize(stackSize); | ||
6608 | } | ||
6609 | |||
6610 | rule__ScopeDeclaration__Group__1 | ||
6611 | @init { | ||
6612 | int stackSize = keepStackSize(); | ||
6613 | } | ||
6614 | : | ||
6615 | rule__ScopeDeclaration__Group__1__Impl | ||
6616 | rule__ScopeDeclaration__Group__2 | ||
6617 | ; | ||
6618 | finally { | ||
6619 | restoreStackSize(stackSize); | ||
6620 | } | ||
6621 | |||
6622 | rule__ScopeDeclaration__Group__1__Impl | ||
6623 | @init { | ||
6624 | int stackSize = keepStackSize(); | ||
6625 | } | ||
6626 | : | ||
6627 | ( | ||
6628 | { before(grammarAccess.getScopeDeclarationAccess().getNameAssignment_1()); } | ||
6629 | (rule__ScopeDeclaration__NameAssignment_1) | ||
6630 | { after(grammarAccess.getScopeDeclarationAccess().getNameAssignment_1()); } | ||
6631 | ) | ||
6632 | ; | ||
6633 | finally { | ||
6634 | restoreStackSize(stackSize); | ||
6635 | } | ||
6636 | |||
6637 | rule__ScopeDeclaration__Group__2 | ||
6638 | @init { | ||
6639 | int stackSize = keepStackSize(); | ||
6640 | } | ||
6641 | : | ||
6642 | rule__ScopeDeclaration__Group__2__Impl | ||
6643 | ; | ||
6644 | finally { | ||
6645 | restoreStackSize(stackSize); | ||
6646 | } | ||
6647 | |||
6648 | rule__ScopeDeclaration__Group__2__Impl | ||
6649 | @init { | ||
6650 | int stackSize = keepStackSize(); | ||
6651 | } | ||
6652 | : | ||
6653 | ( | ||
6654 | { before(grammarAccess.getScopeDeclarationAccess().getSpecificationAssignment_2()); } | ||
6655 | (rule__ScopeDeclaration__SpecificationAssignment_2) | ||
6656 | { after(grammarAccess.getScopeDeclarationAccess().getSpecificationAssignment_2()); } | ||
6657 | ) | ||
6658 | ; | ||
6659 | finally { | ||
6660 | restoreStackSize(stackSize); | ||
6661 | } | ||
6662 | |||
6663 | |||
6664 | rule__GenerationTask__Group__0 | ||
6665 | @init { | ||
6666 | int stackSize = keepStackSize(); | ||
6667 | } | ||
6668 | : | ||
6669 | rule__GenerationTask__Group__0__Impl | ||
6670 | rule__GenerationTask__Group__1 | ||
6671 | ; | ||
6672 | finally { | ||
6673 | restoreStackSize(stackSize); | ||
6674 | } | ||
6675 | |||
6676 | rule__GenerationTask__Group__0__Impl | ||
6677 | @init { | ||
6678 | int stackSize = keepStackSize(); | ||
6679 | } | ||
6680 | : | ||
6681 | ( | ||
6682 | { before(grammarAccess.getGenerationTaskAccess().getGenerateKeyword_0()); } | ||
6683 | 'generate' | ||
6684 | { after(grammarAccess.getGenerationTaskAccess().getGenerateKeyword_0()); } | ||
6685 | ) | ||
6686 | ; | ||
6687 | finally { | ||
6688 | restoreStackSize(stackSize); | ||
6689 | } | ||
6690 | |||
6691 | rule__GenerationTask__Group__1 | ||
6692 | @init { | ||
6693 | int stackSize = keepStackSize(); | ||
6694 | } | ||
6695 | : | ||
6696 | rule__GenerationTask__Group__1__Impl | ||
6697 | rule__GenerationTask__Group__2 | ||
6698 | ; | ||
6699 | finally { | ||
6700 | restoreStackSize(stackSize); | ||
6701 | } | ||
6702 | |||
6703 | rule__GenerationTask__Group__1__Impl | ||
6704 | @init { | ||
6705 | int stackSize = keepStackSize(); | ||
6706 | } | ||
6707 | : | ||
6708 | ( | ||
6709 | { before(grammarAccess.getGenerationTaskAccess().getGenerationTaskAction_1()); } | ||
6710 | () | ||
6711 | { after(grammarAccess.getGenerationTaskAccess().getGenerationTaskAction_1()); } | ||
6712 | ) | ||
6713 | ; | ||
6714 | finally { | ||
6715 | restoreStackSize(stackSize); | ||
6716 | } | ||
6717 | |||
6718 | rule__GenerationTask__Group__2 | ||
6719 | @init { | ||
6720 | int stackSize = keepStackSize(); | ||
6721 | } | ||
6722 | : | ||
6723 | rule__GenerationTask__Group__2__Impl | ||
6724 | rule__GenerationTask__Group__3 | ||
6725 | ; | ||
6726 | finally { | ||
6727 | restoreStackSize(stackSize); | ||
6728 | } | ||
6729 | |||
6730 | rule__GenerationTask__Group__2__Impl | ||
6731 | @init { | ||
6732 | int stackSize = keepStackSize(); | ||
6733 | } | ||
6734 | : | ||
6735 | ( | ||
6736 | { before(grammarAccess.getGenerationTaskAccess().getLeftCurlyBracketKeyword_2()); } | ||
6737 | '{' | ||
6738 | { after(grammarAccess.getGenerationTaskAccess().getLeftCurlyBracketKeyword_2()); } | ||
6739 | ) | ||
6740 | ; | ||
6741 | finally { | ||
6742 | restoreStackSize(stackSize); | ||
6743 | } | ||
6744 | |||
6745 | rule__GenerationTask__Group__3 | ||
6746 | @init { | ||
6747 | int stackSize = keepStackSize(); | ||
6748 | } | ||
6749 | : | ||
6750 | rule__GenerationTask__Group__3__Impl | ||
6751 | rule__GenerationTask__Group__4 | ||
6752 | ; | ||
6753 | finally { | ||
6754 | restoreStackSize(stackSize); | ||
6755 | } | ||
6756 | |||
6757 | rule__GenerationTask__Group__3__Impl | ||
6758 | @init { | ||
6759 | int stackSize = keepStackSize(); | ||
6760 | } | ||
6761 | : | ||
6762 | ( | ||
6763 | { before(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); } | ||
6764 | (rule__GenerationTask__UnorderedGroup_3) | ||
6765 | { after(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); } | ||
6766 | ) | ||
6767 | ; | ||
6768 | finally { | ||
6769 | restoreStackSize(stackSize); | ||
6770 | } | ||
6771 | |||
6772 | rule__GenerationTask__Group__4 | ||
6773 | @init { | ||
6774 | int stackSize = keepStackSize(); | ||
6775 | } | ||
6776 | : | ||
6777 | rule__GenerationTask__Group__4__Impl | ||
6778 | ; | ||
6779 | finally { | ||
6780 | restoreStackSize(stackSize); | ||
6781 | } | ||
6782 | |||
6783 | rule__GenerationTask__Group__4__Impl | ||
6784 | @init { | ||
6785 | int stackSize = keepStackSize(); | ||
6786 | } | ||
6787 | : | ||
6788 | ( | ||
6789 | { before(grammarAccess.getGenerationTaskAccess().getRightCurlyBracketKeyword_4()); } | ||
6790 | '}' | ||
6791 | { after(grammarAccess.getGenerationTaskAccess().getRightCurlyBracketKeyword_4()); } | ||
6792 | ) | ||
6793 | ; | ||
6794 | finally { | ||
6795 | restoreStackSize(stackSize); | ||
6796 | } | ||
6797 | |||
6798 | |||
6799 | rule__GenerationTask__Group_3_0__0 | ||
6800 | @init { | ||
6801 | int stackSize = keepStackSize(); | ||
6802 | } | ||
6803 | : | ||
6804 | rule__GenerationTask__Group_3_0__0__Impl | ||
6805 | rule__GenerationTask__Group_3_0__1 | ||
6806 | ; | ||
6807 | finally { | ||
6808 | restoreStackSize(stackSize); | ||
6809 | } | ||
6810 | |||
6811 | rule__GenerationTask__Group_3_0__0__Impl | ||
6812 | @init { | ||
6813 | int stackSize = keepStackSize(); | ||
6814 | } | ||
6815 | : | ||
6816 | ( | ||
6817 | { before(grammarAccess.getGenerationTaskAccess().getMetamodelKeyword_3_0_0()); } | ||
6818 | 'metamodel' | ||
6819 | { after(grammarAccess.getGenerationTaskAccess().getMetamodelKeyword_3_0_0()); } | ||
6820 | ) | ||
6821 | ; | ||
6822 | finally { | ||
6823 | restoreStackSize(stackSize); | ||
6824 | } | ||
6825 | |||
6826 | rule__GenerationTask__Group_3_0__1 | ||
6827 | @init { | ||
6828 | int stackSize = keepStackSize(); | ||
6829 | } | ||
6830 | : | ||
6831 | rule__GenerationTask__Group_3_0__1__Impl | ||
6832 | rule__GenerationTask__Group_3_0__2 | ||
6833 | ; | ||
6834 | finally { | ||
6835 | restoreStackSize(stackSize); | ||
6836 | } | ||
6837 | |||
6838 | rule__GenerationTask__Group_3_0__1__Impl | ||
6839 | @init { | ||
6840 | int stackSize = keepStackSize(); | ||
6841 | } | ||
6842 | : | ||
6843 | ( | ||
6844 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_0_1()); } | ||
6845 | '=' | ||
6846 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_0_1()); } | ||
6847 | ) | ||
6848 | ; | ||
6849 | finally { | ||
6850 | restoreStackSize(stackSize); | ||
6851 | } | ||
6852 | |||
6853 | rule__GenerationTask__Group_3_0__2 | ||
6854 | @init { | ||
6855 | int stackSize = keepStackSize(); | ||
6856 | } | ||
6857 | : | ||
6858 | rule__GenerationTask__Group_3_0__2__Impl | ||
6859 | ; | ||
6860 | finally { | ||
6861 | restoreStackSize(stackSize); | ||
6862 | } | ||
6863 | |||
6864 | rule__GenerationTask__Group_3_0__2__Impl | ||
6865 | @init { | ||
6866 | int stackSize = keepStackSize(); | ||
6867 | } | ||
6868 | : | ||
6869 | ( | ||
6870 | { before(grammarAccess.getGenerationTaskAccess().getMetamodelAssignment_3_0_2()); } | ||
6871 | (rule__GenerationTask__MetamodelAssignment_3_0_2) | ||
6872 | { after(grammarAccess.getGenerationTaskAccess().getMetamodelAssignment_3_0_2()); } | ||
6873 | ) | ||
6874 | ; | ||
6875 | finally { | ||
6876 | restoreStackSize(stackSize); | ||
6877 | } | ||
6878 | |||
6879 | |||
6880 | rule__GenerationTask__Group_3_1__0 | ||
6881 | @init { | ||
6882 | int stackSize = keepStackSize(); | ||
6883 | } | ||
6884 | : | ||
6885 | rule__GenerationTask__Group_3_1__0__Impl | ||
6886 | rule__GenerationTask__Group_3_1__1 | ||
6887 | ; | ||
6888 | finally { | ||
6889 | restoreStackSize(stackSize); | ||
6890 | } | ||
6891 | |||
6892 | rule__GenerationTask__Group_3_1__0__Impl | ||
6893 | @init { | ||
6894 | int stackSize = keepStackSize(); | ||
6895 | } | ||
6896 | : | ||
6897 | ( | ||
6898 | { before(grammarAccess.getGenerationTaskAccess().getPartialModelKeyword_3_1_0()); } | ||
6899 | 'partial-model' | ||
6900 | { after(grammarAccess.getGenerationTaskAccess().getPartialModelKeyword_3_1_0()); } | ||
6901 | ) | ||
6902 | ; | ||
6903 | finally { | ||
6904 | restoreStackSize(stackSize); | ||
6905 | } | ||
6906 | |||
6907 | rule__GenerationTask__Group_3_1__1 | ||
6908 | @init { | ||
6909 | int stackSize = keepStackSize(); | ||
6910 | } | ||
6911 | : | ||
6912 | rule__GenerationTask__Group_3_1__1__Impl | ||
6913 | rule__GenerationTask__Group_3_1__2 | ||
6914 | ; | ||
6915 | finally { | ||
6916 | restoreStackSize(stackSize); | ||
6917 | } | ||
6918 | |||
6919 | rule__GenerationTask__Group_3_1__1__Impl | ||
6920 | @init { | ||
6921 | int stackSize = keepStackSize(); | ||
6922 | } | ||
6923 | : | ||
6924 | ( | ||
6925 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_1_1()); } | ||
6926 | '=' | ||
6927 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_1_1()); } | ||
6928 | ) | ||
6929 | ; | ||
6930 | finally { | ||
6931 | restoreStackSize(stackSize); | ||
6932 | } | ||
6933 | |||
6934 | rule__GenerationTask__Group_3_1__2 | ||
6935 | @init { | ||
6936 | int stackSize = keepStackSize(); | ||
6937 | } | ||
6938 | : | ||
6939 | rule__GenerationTask__Group_3_1__2__Impl | ||
6940 | ; | ||
6941 | finally { | ||
6942 | restoreStackSize(stackSize); | ||
6943 | } | ||
6944 | |||
6945 | rule__GenerationTask__Group_3_1__2__Impl | ||
6946 | @init { | ||
6947 | int stackSize = keepStackSize(); | ||
6948 | } | ||
6949 | : | ||
6950 | ( | ||
6951 | { before(grammarAccess.getGenerationTaskAccess().getPartialModelAssignment_3_1_2()); } | ||
6952 | (rule__GenerationTask__PartialModelAssignment_3_1_2) | ||
6953 | { after(grammarAccess.getGenerationTaskAccess().getPartialModelAssignment_3_1_2()); } | ||
6954 | ) | ||
6955 | ; | ||
6956 | finally { | ||
6957 | restoreStackSize(stackSize); | ||
6958 | } | ||
6959 | |||
6960 | |||
6961 | rule__GenerationTask__Group_3_2__0 | ||
6962 | @init { | ||
6963 | int stackSize = keepStackSize(); | ||
6964 | } | ||
6965 | : | ||
6966 | rule__GenerationTask__Group_3_2__0__Impl | ||
6967 | rule__GenerationTask__Group_3_2__1 | ||
6968 | ; | ||
6969 | finally { | ||
6970 | restoreStackSize(stackSize); | ||
6971 | } | ||
6972 | |||
6973 | rule__GenerationTask__Group_3_2__0__Impl | ||
6974 | @init { | ||
6975 | int stackSize = keepStackSize(); | ||
6976 | } | ||
6977 | : | ||
6978 | ( | ||
6979 | { before(grammarAccess.getGenerationTaskAccess().getPatternsKeyword_3_2_0()); } | ||
6980 | 'patterns' | ||
6981 | { after(grammarAccess.getGenerationTaskAccess().getPatternsKeyword_3_2_0()); } | ||
6982 | ) | ||
6983 | ; | ||
6984 | finally { | ||
6985 | restoreStackSize(stackSize); | ||
6986 | } | ||
6987 | |||
6988 | rule__GenerationTask__Group_3_2__1 | ||
6989 | @init { | ||
6990 | int stackSize = keepStackSize(); | ||
6991 | } | ||
6992 | : | ||
6993 | rule__GenerationTask__Group_3_2__1__Impl | ||
6994 | rule__GenerationTask__Group_3_2__2 | ||
6995 | ; | ||
6996 | finally { | ||
6997 | restoreStackSize(stackSize); | ||
6998 | } | ||
6999 | |||
7000 | rule__GenerationTask__Group_3_2__1__Impl | ||
7001 | @init { | ||
7002 | int stackSize = keepStackSize(); | ||
7003 | } | ||
7004 | : | ||
7005 | ( | ||
7006 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_2_1()); } | ||
7007 | '=' | ||
7008 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_2_1()); } | ||
7009 | ) | ||
7010 | ; | ||
7011 | finally { | ||
7012 | restoreStackSize(stackSize); | ||
7013 | } | ||
7014 | |||
7015 | rule__GenerationTask__Group_3_2__2 | ||
7016 | @init { | ||
7017 | int stackSize = keepStackSize(); | ||
7018 | } | ||
7019 | : | ||
7020 | rule__GenerationTask__Group_3_2__2__Impl | ||
7021 | ; | ||
7022 | finally { | ||
7023 | restoreStackSize(stackSize); | ||
7024 | } | ||
7025 | |||
7026 | rule__GenerationTask__Group_3_2__2__Impl | ||
7027 | @init { | ||
7028 | int stackSize = keepStackSize(); | ||
7029 | } | ||
7030 | : | ||
7031 | ( | ||
7032 | { before(grammarAccess.getGenerationTaskAccess().getPatternsAssignment_3_2_2()); } | ||
7033 | (rule__GenerationTask__PatternsAssignment_3_2_2) | ||
7034 | { after(grammarAccess.getGenerationTaskAccess().getPatternsAssignment_3_2_2()); } | ||
7035 | ) | ||
7036 | ; | ||
7037 | finally { | ||
7038 | restoreStackSize(stackSize); | ||
7039 | } | ||
7040 | |||
7041 | |||
7042 | rule__GenerationTask__Group_3_3__0 | ||
7043 | @init { | ||
7044 | int stackSize = keepStackSize(); | ||
7045 | } | ||
7046 | : | ||
7047 | rule__GenerationTask__Group_3_3__0__Impl | ||
7048 | rule__GenerationTask__Group_3_3__1 | ||
7049 | ; | ||
7050 | finally { | ||
7051 | restoreStackSize(stackSize); | ||
7052 | } | ||
7053 | |||
7054 | rule__GenerationTask__Group_3_3__0__Impl | ||
7055 | @init { | ||
7056 | int stackSize = keepStackSize(); | ||
7057 | } | ||
7058 | : | ||
7059 | ( | ||
7060 | { before(grammarAccess.getGenerationTaskAccess().getScopeKeyword_3_3_0()); } | ||
7061 | 'scope' | ||
7062 | { after(grammarAccess.getGenerationTaskAccess().getScopeKeyword_3_3_0()); } | ||
7063 | ) | ||
7064 | ; | ||
7065 | finally { | ||
7066 | restoreStackSize(stackSize); | ||
7067 | } | ||
7068 | |||
7069 | rule__GenerationTask__Group_3_3__1 | ||
7070 | @init { | ||
7071 | int stackSize = keepStackSize(); | ||
7072 | } | ||
7073 | : | ||
7074 | rule__GenerationTask__Group_3_3__1__Impl | ||
7075 | rule__GenerationTask__Group_3_3__2 | ||
7076 | ; | ||
7077 | finally { | ||
7078 | restoreStackSize(stackSize); | ||
7079 | } | ||
7080 | |||
7081 | rule__GenerationTask__Group_3_3__1__Impl | ||
7082 | @init { | ||
7083 | int stackSize = keepStackSize(); | ||
7084 | } | ||
7085 | : | ||
7086 | ( | ||
7087 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_3_1()); } | ||
7088 | '=' | ||
7089 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_3_1()); } | ||
7090 | ) | ||
7091 | ; | ||
7092 | finally { | ||
7093 | restoreStackSize(stackSize); | ||
7094 | } | ||
7095 | |||
7096 | rule__GenerationTask__Group_3_3__2 | ||
7097 | @init { | ||
7098 | int stackSize = keepStackSize(); | ||
7099 | } | ||
7100 | : | ||
7101 | rule__GenerationTask__Group_3_3__2__Impl | ||
7102 | ; | ||
7103 | finally { | ||
7104 | restoreStackSize(stackSize); | ||
7105 | } | ||
7106 | |||
7107 | rule__GenerationTask__Group_3_3__2__Impl | ||
7108 | @init { | ||
7109 | int stackSize = keepStackSize(); | ||
7110 | } | ||
7111 | : | ||
7112 | ( | ||
7113 | { before(grammarAccess.getGenerationTaskAccess().getScopeAssignment_3_3_2()); } | ||
7114 | (rule__GenerationTask__ScopeAssignment_3_3_2) | ||
7115 | { after(grammarAccess.getGenerationTaskAccess().getScopeAssignment_3_3_2()); } | ||
7116 | ) | ||
7117 | ; | ||
7118 | finally { | ||
7119 | restoreStackSize(stackSize); | ||
7120 | } | ||
7121 | |||
7122 | |||
7123 | rule__GenerationTask__Group_3_4__0 | ||
7124 | @init { | ||
7125 | int stackSize = keepStackSize(); | ||
7126 | } | ||
7127 | : | ||
7128 | rule__GenerationTask__Group_3_4__0__Impl | ||
7129 | rule__GenerationTask__Group_3_4__1 | ||
7130 | ; | ||
7131 | finally { | ||
7132 | restoreStackSize(stackSize); | ||
7133 | } | ||
7134 | |||
7135 | rule__GenerationTask__Group_3_4__0__Impl | ||
7136 | @init { | ||
7137 | int stackSize = keepStackSize(); | ||
7138 | } | ||
7139 | : | ||
7140 | ( | ||
7141 | { before(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedAssignment_3_4_0()); } | ||
7142 | (rule__GenerationTask__NumberSpecifiedAssignment_3_4_0) | ||
7143 | { after(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedAssignment_3_4_0()); } | ||
7144 | ) | ||
7145 | ; | ||
7146 | finally { | ||
7147 | restoreStackSize(stackSize); | ||
7148 | } | ||
7149 | |||
7150 | rule__GenerationTask__Group_3_4__1 | ||
7151 | @init { | ||
7152 | int stackSize = keepStackSize(); | ||
7153 | } | ||
7154 | : | ||
7155 | rule__GenerationTask__Group_3_4__1__Impl | ||
7156 | rule__GenerationTask__Group_3_4__2 | ||
7157 | ; | ||
7158 | finally { | ||
7159 | restoreStackSize(stackSize); | ||
7160 | } | ||
7161 | |||
7162 | rule__GenerationTask__Group_3_4__1__Impl | ||
7163 | @init { | ||
7164 | int stackSize = keepStackSize(); | ||
7165 | } | ||
7166 | : | ||
7167 | ( | ||
7168 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_4_1()); } | ||
7169 | '=' | ||
7170 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_4_1()); } | ||
7171 | ) | ||
7172 | ; | ||
7173 | finally { | ||
7174 | restoreStackSize(stackSize); | ||
7175 | } | ||
7176 | |||
7177 | rule__GenerationTask__Group_3_4__2 | ||
7178 | @init { | ||
7179 | int stackSize = keepStackSize(); | ||
7180 | } | ||
7181 | : | ||
7182 | rule__GenerationTask__Group_3_4__2__Impl | ||
7183 | ; | ||
7184 | finally { | ||
7185 | restoreStackSize(stackSize); | ||
7186 | } | ||
7187 | |||
7188 | rule__GenerationTask__Group_3_4__2__Impl | ||
7189 | @init { | ||
7190 | int stackSize = keepStackSize(); | ||
7191 | } | ||
7192 | : | ||
7193 | ( | ||
7194 | { before(grammarAccess.getGenerationTaskAccess().getNumberAssignment_3_4_2()); } | ||
7195 | (rule__GenerationTask__NumberAssignment_3_4_2) | ||
7196 | { after(grammarAccess.getGenerationTaskAccess().getNumberAssignment_3_4_2()); } | ||
7197 | ) | ||
7198 | ; | ||
7199 | finally { | ||
7200 | restoreStackSize(stackSize); | ||
7201 | } | ||
7202 | |||
7203 | |||
7204 | rule__GenerationTask__Group_3_5__0 | ||
7205 | @init { | ||
7206 | int stackSize = keepStackSize(); | ||
7207 | } | ||
7208 | : | ||
7209 | rule__GenerationTask__Group_3_5__0__Impl | ||
7210 | rule__GenerationTask__Group_3_5__1 | ||
7211 | ; | ||
7212 | finally { | ||
7213 | restoreStackSize(stackSize); | ||
7214 | } | ||
7215 | |||
7216 | rule__GenerationTask__Group_3_5__0__Impl | ||
7217 | @init { | ||
7218 | int stackSize = keepStackSize(); | ||
7219 | } | ||
7220 | : | ||
7221 | ( | ||
7222 | { before(grammarAccess.getGenerationTaskAccess().getRunSpecifiedAssignment_3_5_0()); } | ||
7223 | (rule__GenerationTask__RunSpecifiedAssignment_3_5_0) | ||
7224 | { after(grammarAccess.getGenerationTaskAccess().getRunSpecifiedAssignment_3_5_0()); } | ||
7225 | ) | ||
7226 | ; | ||
7227 | finally { | ||
7228 | restoreStackSize(stackSize); | ||
7229 | } | ||
7230 | |||
7231 | rule__GenerationTask__Group_3_5__1 | ||
7232 | @init { | ||
7233 | int stackSize = keepStackSize(); | ||
7234 | } | ||
7235 | : | ||
7236 | rule__GenerationTask__Group_3_5__1__Impl | ||
7237 | rule__GenerationTask__Group_3_5__2 | ||
7238 | ; | ||
7239 | finally { | ||
7240 | restoreStackSize(stackSize); | ||
7241 | } | ||
7242 | |||
7243 | rule__GenerationTask__Group_3_5__1__Impl | ||
7244 | @init { | ||
7245 | int stackSize = keepStackSize(); | ||
7246 | } | ||
7247 | : | ||
7248 | ( | ||
7249 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_5_1()); } | ||
7250 | '=' | ||
7251 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_5_1()); } | ||
7252 | ) | ||
7253 | ; | ||
7254 | finally { | ||
7255 | restoreStackSize(stackSize); | ||
7256 | } | ||
7257 | |||
7258 | rule__GenerationTask__Group_3_5__2 | ||
7259 | @init { | ||
7260 | int stackSize = keepStackSize(); | ||
7261 | } | ||
7262 | : | ||
7263 | rule__GenerationTask__Group_3_5__2__Impl | ||
7264 | ; | ||
7265 | finally { | ||
7266 | restoreStackSize(stackSize); | ||
7267 | } | ||
7268 | |||
7269 | rule__GenerationTask__Group_3_5__2__Impl | ||
7270 | @init { | ||
7271 | int stackSize = keepStackSize(); | ||
7272 | } | ||
7273 | : | ||
7274 | ( | ||
7275 | { before(grammarAccess.getGenerationTaskAccess().getRunsAssignment_3_5_2()); } | ||
7276 | (rule__GenerationTask__RunsAssignment_3_5_2) | ||
7277 | { after(grammarAccess.getGenerationTaskAccess().getRunsAssignment_3_5_2()); } | ||
7278 | ) | ||
7279 | ; | ||
7280 | finally { | ||
7281 | restoreStackSize(stackSize); | ||
7282 | } | ||
7283 | |||
7284 | |||
7285 | rule__GenerationTask__Group_3_6__0 | ||
7286 | @init { | ||
7287 | int stackSize = keepStackSize(); | ||
7288 | } | ||
7289 | : | ||
7290 | rule__GenerationTask__Group_3_6__0__Impl | ||
7291 | rule__GenerationTask__Group_3_6__1 | ||
7292 | ; | ||
7293 | finally { | ||
7294 | restoreStackSize(stackSize); | ||
7295 | } | ||
7296 | |||
7297 | rule__GenerationTask__Group_3_6__0__Impl | ||
7298 | @init { | ||
7299 | int stackSize = keepStackSize(); | ||
7300 | } | ||
7301 | : | ||
7302 | ( | ||
7303 | { before(grammarAccess.getGenerationTaskAccess().getSolverKeyword_3_6_0()); } | ||
7304 | 'solver' | ||
7305 | { after(grammarAccess.getGenerationTaskAccess().getSolverKeyword_3_6_0()); } | ||
7306 | ) | ||
7307 | ; | ||
7308 | finally { | ||
7309 | restoreStackSize(stackSize); | ||
7310 | } | ||
7311 | |||
7312 | rule__GenerationTask__Group_3_6__1 | ||
7313 | @init { | ||
7314 | int stackSize = keepStackSize(); | ||
7315 | } | ||
7316 | : | ||
7317 | rule__GenerationTask__Group_3_6__1__Impl | ||
7318 | rule__GenerationTask__Group_3_6__2 | ||
7319 | ; | ||
7320 | finally { | ||
7321 | restoreStackSize(stackSize); | ||
7322 | } | ||
7323 | |||
7324 | rule__GenerationTask__Group_3_6__1__Impl | ||
7325 | @init { | ||
7326 | int stackSize = keepStackSize(); | ||
7327 | } | ||
7328 | : | ||
7329 | ( | ||
7330 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_6_1()); } | ||
7331 | '=' | ||
7332 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_6_1()); } | ||
7333 | ) | ||
7334 | ; | ||
7335 | finally { | ||
7336 | restoreStackSize(stackSize); | ||
7337 | } | ||
7338 | |||
7339 | rule__GenerationTask__Group_3_6__2 | ||
7340 | @init { | ||
7341 | int stackSize = keepStackSize(); | ||
7342 | } | ||
7343 | : | ||
7344 | rule__GenerationTask__Group_3_6__2__Impl | ||
7345 | ; | ||
7346 | finally { | ||
7347 | restoreStackSize(stackSize); | ||
7348 | } | ||
7349 | |||
7350 | rule__GenerationTask__Group_3_6__2__Impl | ||
7351 | @init { | ||
7352 | int stackSize = keepStackSize(); | ||
7353 | } | ||
7354 | : | ||
7355 | ( | ||
7356 | { before(grammarAccess.getGenerationTaskAccess().getSolverAssignment_3_6_2()); } | ||
7357 | (rule__GenerationTask__SolverAssignment_3_6_2) | ||
7358 | { after(grammarAccess.getGenerationTaskAccess().getSolverAssignment_3_6_2()); } | ||
7359 | ) | ||
7360 | ; | ||
7361 | finally { | ||
7362 | restoreStackSize(stackSize); | ||
7363 | } | ||
7364 | |||
7365 | |||
7366 | rule__GenerationTask__Group_3_7__0 | ||
7367 | @init { | ||
7368 | int stackSize = keepStackSize(); | ||
7369 | } | ||
7370 | : | ||
7371 | rule__GenerationTask__Group_3_7__0__Impl | ||
7372 | rule__GenerationTask__Group_3_7__1 | ||
7373 | ; | ||
7374 | finally { | ||
7375 | restoreStackSize(stackSize); | ||
7376 | } | ||
7377 | |||
7378 | rule__GenerationTask__Group_3_7__0__Impl | ||
7379 | @init { | ||
7380 | int stackSize = keepStackSize(); | ||
7381 | } | ||
7382 | : | ||
7383 | ( | ||
7384 | { before(grammarAccess.getGenerationTaskAccess().getConfigKeyword_3_7_0()); } | ||
7385 | 'config' | ||
7386 | { after(grammarAccess.getGenerationTaskAccess().getConfigKeyword_3_7_0()); } | ||
7387 | ) | ||
7388 | ; | ||
7389 | finally { | ||
7390 | restoreStackSize(stackSize); | ||
7391 | } | ||
7392 | |||
7393 | rule__GenerationTask__Group_3_7__1 | ||
7394 | @init { | ||
7395 | int stackSize = keepStackSize(); | ||
7396 | } | ||
7397 | : | ||
7398 | rule__GenerationTask__Group_3_7__1__Impl | ||
7399 | rule__GenerationTask__Group_3_7__2 | ||
7400 | ; | ||
7401 | finally { | ||
7402 | restoreStackSize(stackSize); | ||
7403 | } | ||
7404 | |||
7405 | rule__GenerationTask__Group_3_7__1__Impl | ||
7406 | @init { | ||
7407 | int stackSize = keepStackSize(); | ||
7408 | } | ||
7409 | : | ||
7410 | ( | ||
7411 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_7_1()); } | ||
7412 | '=' | ||
7413 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_7_1()); } | ||
7414 | ) | ||
7415 | ; | ||
7416 | finally { | ||
7417 | restoreStackSize(stackSize); | ||
7418 | } | ||
7419 | |||
7420 | rule__GenerationTask__Group_3_7__2 | ||
7421 | @init { | ||
7422 | int stackSize = keepStackSize(); | ||
7423 | } | ||
7424 | : | ||
7425 | rule__GenerationTask__Group_3_7__2__Impl | ||
7426 | ; | ||
7427 | finally { | ||
7428 | restoreStackSize(stackSize); | ||
7429 | } | ||
7430 | |||
7431 | rule__GenerationTask__Group_3_7__2__Impl | ||
7432 | @init { | ||
7433 | int stackSize = keepStackSize(); | ||
7434 | } | ||
7435 | : | ||
7436 | ( | ||
7437 | { before(grammarAccess.getGenerationTaskAccess().getConfigAssignment_3_7_2()); } | ||
7438 | (rule__GenerationTask__ConfigAssignment_3_7_2) | ||
7439 | { after(grammarAccess.getGenerationTaskAccess().getConfigAssignment_3_7_2()); } | ||
7440 | ) | ||
7441 | ; | ||
7442 | finally { | ||
7443 | restoreStackSize(stackSize); | ||
7444 | } | ||
7445 | |||
7446 | |||
7447 | rule__GenerationTask__Group_3_8__0 | ||
7448 | @init { | ||
7449 | int stackSize = keepStackSize(); | ||
7450 | } | ||
7451 | : | ||
7452 | rule__GenerationTask__Group_3_8__0__Impl | ||
7453 | rule__GenerationTask__Group_3_8__1 | ||
7454 | ; | ||
7455 | finally { | ||
7456 | restoreStackSize(stackSize); | ||
7457 | } | ||
7458 | |||
7459 | rule__GenerationTask__Group_3_8__0__Impl | ||
7460 | @init { | ||
7461 | int stackSize = keepStackSize(); | ||
7462 | } | ||
7463 | : | ||
7464 | ( | ||
7465 | { before(grammarAccess.getGenerationTaskAccess().getDebugKeyword_3_8_0()); } | ||
7466 | 'debug' | ||
7467 | { after(grammarAccess.getGenerationTaskAccess().getDebugKeyword_3_8_0()); } | ||
7468 | ) | ||
7469 | ; | ||
7470 | finally { | ||
7471 | restoreStackSize(stackSize); | ||
7472 | } | ||
7473 | |||
7474 | rule__GenerationTask__Group_3_8__1 | ||
7475 | @init { | ||
7476 | int stackSize = keepStackSize(); | ||
7477 | } | ||
7478 | : | ||
7479 | rule__GenerationTask__Group_3_8__1__Impl | ||
7480 | rule__GenerationTask__Group_3_8__2 | ||
7481 | ; | ||
7482 | finally { | ||
7483 | restoreStackSize(stackSize); | ||
7484 | } | ||
7485 | |||
7486 | rule__GenerationTask__Group_3_8__1__Impl | ||
7487 | @init { | ||
7488 | int stackSize = keepStackSize(); | ||
7489 | } | ||
7490 | : | ||
7491 | ( | ||
7492 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_8_1()); } | ||
7493 | '=' | ||
7494 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_8_1()); } | ||
7495 | ) | ||
7496 | ; | ||
7497 | finally { | ||
7498 | restoreStackSize(stackSize); | ||
7499 | } | ||
7500 | |||
7501 | rule__GenerationTask__Group_3_8__2 | ||
7502 | @init { | ||
7503 | int stackSize = keepStackSize(); | ||
7504 | } | ||
7505 | : | ||
7506 | rule__GenerationTask__Group_3_8__2__Impl | ||
7507 | ; | ||
7508 | finally { | ||
7509 | restoreStackSize(stackSize); | ||
7510 | } | ||
7511 | |||
7512 | rule__GenerationTask__Group_3_8__2__Impl | ||
7513 | @init { | ||
7514 | int stackSize = keepStackSize(); | ||
7515 | } | ||
7516 | : | ||
7517 | ( | ||
7518 | { before(grammarAccess.getGenerationTaskAccess().getDebugFolderAssignment_3_8_2()); } | ||
7519 | (rule__GenerationTask__DebugFolderAssignment_3_8_2) | ||
7520 | { after(grammarAccess.getGenerationTaskAccess().getDebugFolderAssignment_3_8_2()); } | ||
7521 | ) | ||
7522 | ; | ||
7523 | finally { | ||
7524 | restoreStackSize(stackSize); | ||
7525 | } | ||
7526 | |||
7527 | |||
7528 | rule__GenerationTask__Group_3_9__0 | ||
7529 | @init { | ||
7530 | int stackSize = keepStackSize(); | ||
7531 | } | ||
7532 | : | ||
7533 | rule__GenerationTask__Group_3_9__0__Impl | ||
7534 | rule__GenerationTask__Group_3_9__1 | ||
7535 | ; | ||
7536 | finally { | ||
7537 | restoreStackSize(stackSize); | ||
7538 | } | ||
7539 | |||
7540 | rule__GenerationTask__Group_3_9__0__Impl | ||
7541 | @init { | ||
7542 | int stackSize = keepStackSize(); | ||
7543 | } | ||
7544 | : | ||
7545 | ( | ||
7546 | { before(grammarAccess.getGenerationTaskAccess().getLogKeyword_3_9_0()); } | ||
7547 | 'log' | ||
7548 | { after(grammarAccess.getGenerationTaskAccess().getLogKeyword_3_9_0()); } | ||
7549 | ) | ||
7550 | ; | ||
7551 | finally { | ||
7552 | restoreStackSize(stackSize); | ||
7553 | } | ||
7554 | |||
7555 | rule__GenerationTask__Group_3_9__1 | ||
7556 | @init { | ||
7557 | int stackSize = keepStackSize(); | ||
7558 | } | ||
7559 | : | ||
7560 | rule__GenerationTask__Group_3_9__1__Impl | ||
7561 | rule__GenerationTask__Group_3_9__2 | ||
7562 | ; | ||
7563 | finally { | ||
7564 | restoreStackSize(stackSize); | ||
7565 | } | ||
7566 | |||
7567 | rule__GenerationTask__Group_3_9__1__Impl | ||
7568 | @init { | ||
7569 | int stackSize = keepStackSize(); | ||
7570 | } | ||
7571 | : | ||
7572 | ( | ||
7573 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_9_1()); } | ||
7574 | '=' | ||
7575 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_9_1()); } | ||
7576 | ) | ||
7577 | ; | ||
7578 | finally { | ||
7579 | restoreStackSize(stackSize); | ||
7580 | } | ||
7581 | |||
7582 | rule__GenerationTask__Group_3_9__2 | ||
7583 | @init { | ||
7584 | int stackSize = keepStackSize(); | ||
7585 | } | ||
7586 | : | ||
7587 | rule__GenerationTask__Group_3_9__2__Impl | ||
7588 | ; | ||
7589 | finally { | ||
7590 | restoreStackSize(stackSize); | ||
7591 | } | ||
7592 | |||
7593 | rule__GenerationTask__Group_3_9__2__Impl | ||
7594 | @init { | ||
7595 | int stackSize = keepStackSize(); | ||
7596 | } | ||
7597 | : | ||
7598 | ( | ||
7599 | { before(grammarAccess.getGenerationTaskAccess().getTargetLogFileAssignment_3_9_2()); } | ||
7600 | (rule__GenerationTask__TargetLogFileAssignment_3_9_2) | ||
7601 | { after(grammarAccess.getGenerationTaskAccess().getTargetLogFileAssignment_3_9_2()); } | ||
7602 | ) | ||
7603 | ; | ||
7604 | finally { | ||
7605 | restoreStackSize(stackSize); | ||
7606 | } | ||
7607 | |||
7608 | |||
7609 | rule__GenerationTask__Group_3_10__0 | ||
7610 | @init { | ||
7611 | int stackSize = keepStackSize(); | ||
7612 | } | ||
7613 | : | ||
7614 | rule__GenerationTask__Group_3_10__0__Impl | ||
7615 | rule__GenerationTask__Group_3_10__1 | ||
7616 | ; | ||
7617 | finally { | ||
7618 | restoreStackSize(stackSize); | ||
7619 | } | ||
7620 | |||
7621 | rule__GenerationTask__Group_3_10__0__Impl | ||
7622 | @init { | ||
7623 | int stackSize = keepStackSize(); | ||
7624 | } | ||
7625 | : | ||
7626 | ( | ||
7627 | { before(grammarAccess.getGenerationTaskAccess().getStatisticsKeyword_3_10_0()); } | ||
7628 | 'statistics' | ||
7629 | { after(grammarAccess.getGenerationTaskAccess().getStatisticsKeyword_3_10_0()); } | ||
7630 | ) | ||
7631 | ; | ||
7632 | finally { | ||
7633 | restoreStackSize(stackSize); | ||
7634 | } | ||
7635 | |||
7636 | rule__GenerationTask__Group_3_10__1 | ||
7637 | @init { | ||
7638 | int stackSize = keepStackSize(); | ||
7639 | } | ||
7640 | : | ||
7641 | rule__GenerationTask__Group_3_10__1__Impl | ||
7642 | rule__GenerationTask__Group_3_10__2 | ||
7643 | ; | ||
7644 | finally { | ||
7645 | restoreStackSize(stackSize); | ||
7646 | } | ||
7647 | |||
7648 | rule__GenerationTask__Group_3_10__1__Impl | ||
7649 | @init { | ||
7650 | int stackSize = keepStackSize(); | ||
7651 | } | ||
7652 | : | ||
7653 | ( | ||
7654 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_10_1()); } | ||
7655 | '=' | ||
7656 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_10_1()); } | ||
7657 | ) | ||
7658 | ; | ||
7659 | finally { | ||
7660 | restoreStackSize(stackSize); | ||
7661 | } | ||
7662 | |||
7663 | rule__GenerationTask__Group_3_10__2 | ||
7664 | @init { | ||
7665 | int stackSize = keepStackSize(); | ||
7666 | } | ||
7667 | : | ||
7668 | rule__GenerationTask__Group_3_10__2__Impl | ||
7669 | ; | ||
7670 | finally { | ||
7671 | restoreStackSize(stackSize); | ||
7672 | } | ||
7673 | |||
7674 | rule__GenerationTask__Group_3_10__2__Impl | ||
7675 | @init { | ||
7676 | int stackSize = keepStackSize(); | ||
7677 | } | ||
7678 | : | ||
7679 | ( | ||
7680 | { before(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileAssignment_3_10_2()); } | ||
7681 | (rule__GenerationTask__TargetStatisticsFileAssignment_3_10_2) | ||
7682 | { after(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileAssignment_3_10_2()); } | ||
7683 | ) | ||
7684 | ; | ||
7685 | finally { | ||
7686 | restoreStackSize(stackSize); | ||
7687 | } | ||
7688 | |||
7689 | |||
7690 | rule__GenerationTask__Group_3_11__0 | ||
7691 | @init { | ||
7692 | int stackSize = keepStackSize(); | ||
7693 | } | ||
7694 | : | ||
7695 | rule__GenerationTask__Group_3_11__0__Impl | ||
7696 | rule__GenerationTask__Group_3_11__1 | ||
7697 | ; | ||
7698 | finally { | ||
7699 | restoreStackSize(stackSize); | ||
7700 | } | ||
7701 | |||
7702 | rule__GenerationTask__Group_3_11__0__Impl | ||
7703 | @init { | ||
7704 | int stackSize = keepStackSize(); | ||
7705 | } | ||
7706 | : | ||
7707 | ( | ||
7708 | { before(grammarAccess.getGenerationTaskAccess().getOutputKeyword_3_11_0()); } | ||
7709 | 'output' | ||
7710 | { after(grammarAccess.getGenerationTaskAccess().getOutputKeyword_3_11_0()); } | ||
7711 | ) | ||
7712 | ; | ||
7713 | finally { | ||
7714 | restoreStackSize(stackSize); | ||
7715 | } | ||
7716 | |||
7717 | rule__GenerationTask__Group_3_11__1 | ||
7718 | @init { | ||
7719 | int stackSize = keepStackSize(); | ||
7720 | } | ||
7721 | : | ||
7722 | rule__GenerationTask__Group_3_11__1__Impl | ||
7723 | rule__GenerationTask__Group_3_11__2 | ||
7724 | ; | ||
7725 | finally { | ||
7726 | restoreStackSize(stackSize); | ||
7727 | } | ||
7728 | |||
7729 | rule__GenerationTask__Group_3_11__1__Impl | ||
7730 | @init { | ||
7731 | int stackSize = keepStackSize(); | ||
7732 | } | ||
7733 | : | ||
7734 | ( | ||
7735 | { before(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_11_1()); } | ||
7736 | '=' | ||
7737 | { after(grammarAccess.getGenerationTaskAccess().getEqualsSignKeyword_3_11_1()); } | ||
7738 | ) | ||
7739 | ; | ||
7740 | finally { | ||
7741 | restoreStackSize(stackSize); | ||
7742 | } | ||
7743 | |||
7744 | rule__GenerationTask__Group_3_11__2 | ||
7745 | @init { | ||
7746 | int stackSize = keepStackSize(); | ||
7747 | } | ||
7748 | : | ||
7749 | rule__GenerationTask__Group_3_11__2__Impl | ||
7750 | ; | ||
7751 | finally { | ||
7752 | restoreStackSize(stackSize); | ||
7753 | } | ||
7754 | |||
7755 | rule__GenerationTask__Group_3_11__2__Impl | ||
7756 | @init { | ||
7757 | int stackSize = keepStackSize(); | ||
7758 | } | ||
7759 | : | ||
7760 | ( | ||
7761 | { before(grammarAccess.getGenerationTaskAccess().getTagetFolderAssignment_3_11_2()); } | ||
7762 | (rule__GenerationTask__TagetFolderAssignment_3_11_2) | ||
7763 | { after(grammarAccess.getGenerationTaskAccess().getTagetFolderAssignment_3_11_2()); } | ||
7764 | ) | ||
7765 | ; | ||
7766 | finally { | ||
7767 | restoreStackSize(stackSize); | ||
7768 | } | ||
7769 | |||
7770 | |||
7771 | rule__GenerationTask__UnorderedGroup_3 | ||
7772 | @init { | ||
7773 | int stackSize = keepStackSize(); | ||
7774 | getUnorderedGroupHelper().enter(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); | ||
7775 | } | ||
7776 | : | ||
7777 | rule__GenerationTask__UnorderedGroup_3__0 | ||
7778 | ? | ||
7779 | ; | ||
7780 | finally { | ||
7781 | getUnorderedGroupHelper().leave(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); | ||
7782 | restoreStackSize(stackSize); | ||
7783 | } | ||
7784 | |||
7785 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
7786 | @init { | ||
7787 | int stackSize = keepStackSize(); | ||
7788 | boolean selected = false; | ||
7789 | } | ||
7790 | : | ||
7791 | ( | ||
7792 | ( | ||
7793 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 0)}?=>( | ||
7794 | { | ||
7795 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 0); | ||
7796 | } | ||
7797 | { | ||
7798 | selected = true; | ||
7799 | } | ||
7800 | ( | ||
7801 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_0()); } | ||
7802 | (rule__GenerationTask__Group_3_0__0) | ||
7803 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_0()); } | ||
7804 | ) | ||
7805 | ) | ||
7806 | )| | ||
7807 | ( | ||
7808 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 1)}?=>( | ||
7809 | { | ||
7810 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 1); | ||
7811 | } | ||
7812 | { | ||
7813 | selected = true; | ||
7814 | } | ||
7815 | ( | ||
7816 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_1()); } | ||
7817 | (rule__GenerationTask__Group_3_1__0) | ||
7818 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_1()); } | ||
7819 | ) | ||
7820 | ) | ||
7821 | )| | ||
7822 | ( | ||
7823 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 2)}?=>( | ||
7824 | { | ||
7825 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 2); | ||
7826 | } | ||
7827 | { | ||
7828 | selected = true; | ||
7829 | } | ||
7830 | ( | ||
7831 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_2()); } | ||
7832 | (rule__GenerationTask__Group_3_2__0) | ||
7833 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_2()); } | ||
7834 | ) | ||
7835 | ) | ||
7836 | )| | ||
7837 | ( | ||
7838 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 3)}?=>( | ||
7839 | { | ||
7840 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 3); | ||
7841 | } | ||
7842 | { | ||
7843 | selected = true; | ||
7844 | } | ||
7845 | ( | ||
7846 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_3()); } | ||
7847 | (rule__GenerationTask__Group_3_3__0) | ||
7848 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_3()); } | ||
7849 | ) | ||
7850 | ) | ||
7851 | )| | ||
7852 | ( | ||
7853 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 4)}?=>( | ||
7854 | { | ||
7855 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 4); | ||
7856 | } | ||
7857 | { | ||
7858 | selected = true; | ||
7859 | } | ||
7860 | ( | ||
7861 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_4()); } | ||
7862 | (rule__GenerationTask__Group_3_4__0) | ||
7863 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_4()); } | ||
7864 | ) | ||
7865 | ) | ||
7866 | )| | ||
7867 | ( | ||
7868 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 5)}?=>( | ||
7869 | { | ||
7870 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 5); | ||
7871 | } | ||
7872 | { | ||
7873 | selected = true; | ||
7874 | } | ||
7875 | ( | ||
7876 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_5()); } | ||
7877 | (rule__GenerationTask__Group_3_5__0) | ||
7878 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_5()); } | ||
7879 | ) | ||
7880 | ) | ||
7881 | )| | ||
7882 | ( | ||
7883 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 6)}?=>( | ||
7884 | { | ||
7885 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 6); | ||
7886 | } | ||
7887 | { | ||
7888 | selected = true; | ||
7889 | } | ||
7890 | ( | ||
7891 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_6()); } | ||
7892 | (rule__GenerationTask__Group_3_6__0) | ||
7893 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_6()); } | ||
7894 | ) | ||
7895 | ) | ||
7896 | )| | ||
7897 | ( | ||
7898 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 7)}?=>( | ||
7899 | { | ||
7900 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 7); | ||
7901 | } | ||
7902 | { | ||
7903 | selected = true; | ||
7904 | } | ||
7905 | ( | ||
7906 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_7()); } | ||
7907 | (rule__GenerationTask__Group_3_7__0) | ||
7908 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_7()); } | ||
7909 | ) | ||
7910 | ) | ||
7911 | )| | ||
7912 | ( | ||
7913 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 8)}?=>( | ||
7914 | { | ||
7915 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 8); | ||
7916 | } | ||
7917 | { | ||
7918 | selected = true; | ||
7919 | } | ||
7920 | ( | ||
7921 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_8()); } | ||
7922 | (rule__GenerationTask__Group_3_8__0) | ||
7923 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_8()); } | ||
7924 | ) | ||
7925 | ) | ||
7926 | )| | ||
7927 | ( | ||
7928 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 9)}?=>( | ||
7929 | { | ||
7930 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 9); | ||
7931 | } | ||
7932 | { | ||
7933 | selected = true; | ||
7934 | } | ||
7935 | ( | ||
7936 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_9()); } | ||
7937 | (rule__GenerationTask__Group_3_9__0) | ||
7938 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_9()); } | ||
7939 | ) | ||
7940 | ) | ||
7941 | )| | ||
7942 | ( | ||
7943 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 10)}?=>( | ||
7944 | { | ||
7945 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 10); | ||
7946 | } | ||
7947 | { | ||
7948 | selected = true; | ||
7949 | } | ||
7950 | ( | ||
7951 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_10()); } | ||
7952 | (rule__GenerationTask__Group_3_10__0) | ||
7953 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_10()); } | ||
7954 | ) | ||
7955 | ) | ||
7956 | )| | ||
7957 | ( | ||
7958 | {getUnorderedGroupHelper().canSelect(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 11)}?=>( | ||
7959 | { | ||
7960 | getUnorderedGroupHelper().select(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3(), 11); | ||
7961 | } | ||
7962 | { | ||
7963 | selected = true; | ||
7964 | } | ||
7965 | ( | ||
7966 | { before(grammarAccess.getGenerationTaskAccess().getGroup_3_11()); } | ||
7967 | (rule__GenerationTask__Group_3_11__0) | ||
7968 | { after(grammarAccess.getGenerationTaskAccess().getGroup_3_11()); } | ||
7969 | ) | ||
7970 | ) | ||
7971 | ) | ||
7972 | ) | ||
7973 | ; | ||
7974 | finally { | ||
7975 | if (selected) | ||
7976 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3()); | ||
7977 | restoreStackSize(stackSize); | ||
7978 | } | ||
7979 | |||
7980 | rule__GenerationTask__UnorderedGroup_3__0 | ||
7981 | @init { | ||
7982 | int stackSize = keepStackSize(); | ||
7983 | } | ||
7984 | : | ||
7985 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
7986 | rule__GenerationTask__UnorderedGroup_3__1? | ||
7987 | ; | ||
7988 | finally { | ||
7989 | restoreStackSize(stackSize); | ||
7990 | } | ||
7991 | |||
7992 | rule__GenerationTask__UnorderedGroup_3__1 | ||
7993 | @init { | ||
7994 | int stackSize = keepStackSize(); | ||
7995 | } | ||
7996 | : | ||
7997 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
7998 | rule__GenerationTask__UnorderedGroup_3__2? | ||
7999 | ; | ||
8000 | finally { | ||
8001 | restoreStackSize(stackSize); | ||
8002 | } | ||
8003 | |||
8004 | rule__GenerationTask__UnorderedGroup_3__2 | ||
8005 | @init { | ||
8006 | int stackSize = keepStackSize(); | ||
8007 | } | ||
8008 | : | ||
8009 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
8010 | rule__GenerationTask__UnorderedGroup_3__3? | ||
8011 | ; | ||
8012 | finally { | ||
8013 | restoreStackSize(stackSize); | ||
8014 | } | ||
8015 | |||
8016 | rule__GenerationTask__UnorderedGroup_3__3 | ||
8017 | @init { | ||
8018 | int stackSize = keepStackSize(); | ||
8019 | } | ||
8020 | : | ||
8021 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
8022 | rule__GenerationTask__UnorderedGroup_3__4? | ||
8023 | ; | ||
8024 | finally { | ||
8025 | restoreStackSize(stackSize); | ||
8026 | } | ||
8027 | |||
8028 | rule__GenerationTask__UnorderedGroup_3__4 | ||
8029 | @init { | ||
8030 | int stackSize = keepStackSize(); | ||
8031 | } | ||
8032 | : | ||
8033 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
8034 | rule__GenerationTask__UnorderedGroup_3__5? | ||
8035 | ; | ||
8036 | finally { | ||
8037 | restoreStackSize(stackSize); | ||
8038 | } | ||
8039 | |||
8040 | rule__GenerationTask__UnorderedGroup_3__5 | ||
8041 | @init { | ||
8042 | int stackSize = keepStackSize(); | ||
8043 | } | ||
8044 | : | ||
8045 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
8046 | rule__GenerationTask__UnorderedGroup_3__6? | ||
8047 | ; | ||
8048 | finally { | ||
8049 | restoreStackSize(stackSize); | ||
8050 | } | ||
8051 | |||
8052 | rule__GenerationTask__UnorderedGroup_3__6 | ||
8053 | @init { | ||
8054 | int stackSize = keepStackSize(); | ||
8055 | } | ||
8056 | : | ||
8057 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
8058 | rule__GenerationTask__UnorderedGroup_3__7? | ||
8059 | ; | ||
8060 | finally { | ||
8061 | restoreStackSize(stackSize); | ||
8062 | } | ||
8063 | |||
8064 | rule__GenerationTask__UnorderedGroup_3__7 | ||
8065 | @init { | ||
8066 | int stackSize = keepStackSize(); | ||
8067 | } | ||
8068 | : | ||
8069 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
8070 | rule__GenerationTask__UnorderedGroup_3__8? | ||
8071 | ; | ||
8072 | finally { | ||
8073 | restoreStackSize(stackSize); | ||
8074 | } | ||
8075 | |||
8076 | rule__GenerationTask__UnorderedGroup_3__8 | ||
8077 | @init { | ||
8078 | int stackSize = keepStackSize(); | ||
8079 | } | ||
8080 | : | ||
8081 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
8082 | rule__GenerationTask__UnorderedGroup_3__9? | ||
8083 | ; | ||
8084 | finally { | ||
8085 | restoreStackSize(stackSize); | ||
8086 | } | ||
8087 | |||
8088 | rule__GenerationTask__UnorderedGroup_3__9 | ||
8089 | @init { | ||
8090 | int stackSize = keepStackSize(); | ||
8091 | } | ||
8092 | : | ||
8093 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
8094 | rule__GenerationTask__UnorderedGroup_3__10? | ||
8095 | ; | ||
8096 | finally { | ||
8097 | restoreStackSize(stackSize); | ||
8098 | } | ||
8099 | |||
8100 | rule__GenerationTask__UnorderedGroup_3__10 | ||
8101 | @init { | ||
8102 | int stackSize = keepStackSize(); | ||
8103 | } | ||
8104 | : | ||
8105 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
8106 | rule__GenerationTask__UnorderedGroup_3__11? | ||
8107 | ; | ||
8108 | finally { | ||
8109 | restoreStackSize(stackSize); | ||
8110 | } | ||
8111 | |||
8112 | rule__GenerationTask__UnorderedGroup_3__11 | ||
8113 | @init { | ||
8114 | int stackSize = keepStackSize(); | ||
8115 | } | ||
8116 | : | ||
8117 | rule__GenerationTask__UnorderedGroup_3__Impl | ||
8118 | ; | ||
8119 | finally { | ||
8120 | restoreStackSize(stackSize); | ||
8121 | } | ||
8122 | |||
8123 | |||
1312 | rule__ConfigurationScript__ImportsAssignment_0 | 8124 | rule__ConfigurationScript__ImportsAssignment_0 |
1313 | @init { | 8125 | @init { |
1314 | int stackSize = keepStackSize(); | 8126 | int stackSize = keepStackSize(); |
@@ -1377,6 +8189,70 @@ finally { | |||
1377 | restoreStackSize(stackSize); | 8189 | restoreStackSize(stackSize); |
1378 | } | 8190 | } |
1379 | 8191 | ||
8192 | rule__FileSpecification__PathAssignment | ||
8193 | @init { | ||
8194 | int stackSize = keepStackSize(); | ||
8195 | } | ||
8196 | : | ||
8197 | ( | ||
8198 | { before(grammarAccess.getFileSpecificationAccess().getPathSTRINGTerminalRuleCall_0()); } | ||
8199 | RULE_STRING | ||
8200 | { after(grammarAccess.getFileSpecificationAccess().getPathSTRINGTerminalRuleCall_0()); } | ||
8201 | ) | ||
8202 | ; | ||
8203 | finally { | ||
8204 | restoreStackSize(stackSize); | ||
8205 | } | ||
8206 | |||
8207 | rule__FileDeclaration__NameAssignment_1 | ||
8208 | @init { | ||
8209 | int stackSize = keepStackSize(); | ||
8210 | } | ||
8211 | : | ||
8212 | ( | ||
8213 | { before(grammarAccess.getFileDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } | ||
8214 | RULE_ID | ||
8215 | { after(grammarAccess.getFileDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } | ||
8216 | ) | ||
8217 | ; | ||
8218 | finally { | ||
8219 | restoreStackSize(stackSize); | ||
8220 | } | ||
8221 | |||
8222 | rule__FileDeclaration__SpecificationAssignment_3 | ||
8223 | @init { | ||
8224 | int stackSize = keepStackSize(); | ||
8225 | } | ||
8226 | : | ||
8227 | ( | ||
8228 | { before(grammarAccess.getFileDeclarationAccess().getSpecificationFileSpecificationParserRuleCall_3_0()); } | ||
8229 | ruleFileSpecification | ||
8230 | { after(grammarAccess.getFileDeclarationAccess().getSpecificationFileSpecificationParserRuleCall_3_0()); } | ||
8231 | ) | ||
8232 | ; | ||
8233 | finally { | ||
8234 | restoreStackSize(stackSize); | ||
8235 | } | ||
8236 | |||
8237 | rule__FileReference__ReferredAssignment | ||
8238 | @init { | ||
8239 | int stackSize = keepStackSize(); | ||
8240 | } | ||
8241 | : | ||
8242 | ( | ||
8243 | { before(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationCrossReference_0()); } | ||
8244 | ( | ||
8245 | { before(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationIDTerminalRuleCall_0_1()); } | ||
8246 | RULE_ID | ||
8247 | { after(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationIDTerminalRuleCall_0_1()); } | ||
8248 | ) | ||
8249 | { after(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationCrossReference_0()); } | ||
8250 | ) | ||
8251 | ; | ||
8252 | finally { | ||
8253 | restoreStackSize(stackSize); | ||
8254 | } | ||
8255 | |||
1380 | rule__MetamodelSpecification__EntriesAssignment_1 | 8256 | rule__MetamodelSpecification__EntriesAssignment_1 |
1381 | @init { | 8257 | @init { |
1382 | int stackSize = keepStackSize(); | 8258 | int stackSize = keepStackSize(); |
@@ -1415,9 +8291,9 @@ rule__AllPackageEntry__PackageAssignment_1 | |||
1415 | ( | 8291 | ( |
1416 | { before(grammarAccess.getAllPackageEntryAccess().getPackageEPackageCrossReference_1_0()); } | 8292 | { before(grammarAccess.getAllPackageEntryAccess().getPackageEPackageCrossReference_1_0()); } |
1417 | ( | 8293 | ( |
1418 | { before(grammarAccess.getAllPackageEntryAccess().getPackageEPackageIDTerminalRuleCall_1_0_1()); } | 8294 | { before(grammarAccess.getAllPackageEntryAccess().getPackageEPackageQualifiedNameParserRuleCall_1_0_1()); } |
1419 | RULE_ID | 8295 | ruleQualifiedName |
1420 | { after(grammarAccess.getAllPackageEntryAccess().getPackageEPackageIDTerminalRuleCall_1_0_1()); } | 8296 | { after(grammarAccess.getAllPackageEntryAccess().getPackageEPackageQualifiedNameParserRuleCall_1_0_1()); } |
1421 | ) | 8297 | ) |
1422 | { after(grammarAccess.getAllPackageEntryAccess().getPackageEPackageCrossReference_1_0()); } | 8298 | { after(grammarAccess.getAllPackageEntryAccess().getPackageEPackageCrossReference_1_0()); } |
1423 | ) | 8299 | ) |
@@ -1464,9 +8340,9 @@ rule__MetamodelElement__PackageAssignment_0_0 | |||
1464 | ( | 8340 | ( |
1465 | { before(grammarAccess.getMetamodelElementAccess().getPackageEPackageCrossReference_0_0_0()); } | 8341 | { before(grammarAccess.getMetamodelElementAccess().getPackageEPackageCrossReference_0_0_0()); } |
1466 | ( | 8342 | ( |
1467 | { before(grammarAccess.getMetamodelElementAccess().getPackageEPackageIDTerminalRuleCall_0_0_0_1()); } | 8343 | { before(grammarAccess.getMetamodelElementAccess().getPackageEPackageQualifiedNameParserRuleCall_0_0_0_1()); } |
1468 | RULE_ID | 8344 | ruleQualifiedName |
1469 | { after(grammarAccess.getMetamodelElementAccess().getPackageEPackageIDTerminalRuleCall_0_0_0_1()); } | 8345 | { after(grammarAccess.getMetamodelElementAccess().getPackageEPackageQualifiedNameParserRuleCall_0_0_0_1()); } |
1470 | ) | 8346 | ) |
1471 | { after(grammarAccess.getMetamodelElementAccess().getPackageEPackageCrossReference_0_0_0()); } | 8347 | { after(grammarAccess.getMetamodelElementAccess().getPackageEPackageCrossReference_0_0_0()); } |
1472 | ) | 8348 | ) |
@@ -1562,6 +8438,1365 @@ finally { | |||
1562 | restoreStackSize(stackSize); | 8438 | restoreStackSize(stackSize); |
1563 | } | 8439 | } |
1564 | 8440 | ||
8441 | rule__PartialModelSpecification__EntryAssignment_1 | ||
8442 | @init { | ||
8443 | int stackSize = keepStackSize(); | ||
8444 | } | ||
8445 | : | ||
8446 | ( | ||
8447 | { before(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_1_0()); } | ||
8448 | rulePartialModelEntry | ||
8449 | { after(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_1_0()); } | ||
8450 | ) | ||
8451 | ; | ||
8452 | finally { | ||
8453 | restoreStackSize(stackSize); | ||
8454 | } | ||
8455 | |||
8456 | rule__PartialModelSpecification__EntryAssignment_2_1 | ||
8457 | @init { | ||
8458 | int stackSize = keepStackSize(); | ||
8459 | } | ||
8460 | : | ||
8461 | ( | ||
8462 | { before(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_2_1_0()); } | ||
8463 | rulePartialModelEntry | ||
8464 | { after(grammarAccess.getPartialModelSpecificationAccess().getEntryPartialModelEntryParserRuleCall_2_1_0()); } | ||
8465 | ) | ||
8466 | ; | ||
8467 | finally { | ||
8468 | restoreStackSize(stackSize); | ||
8469 | } | ||
8470 | |||
8471 | rule__ModelEntry__PathAssignment | ||
8472 | @init { | ||
8473 | int stackSize = keepStackSize(); | ||
8474 | } | ||
8475 | : | ||
8476 | ( | ||
8477 | { before(grammarAccess.getModelEntryAccess().getPathFileParserRuleCall_0()); } | ||
8478 | ruleFile | ||
8479 | { after(grammarAccess.getModelEntryAccess().getPathFileParserRuleCall_0()); } | ||
8480 | ) | ||
8481 | ; | ||
8482 | finally { | ||
8483 | restoreStackSize(stackSize); | ||
8484 | } | ||
8485 | |||
8486 | rule__FolderEntry__PathAssignment_1 | ||
8487 | @init { | ||
8488 | int stackSize = keepStackSize(); | ||
8489 | } | ||
8490 | : | ||
8491 | ( | ||
8492 | { before(grammarAccess.getFolderEntryAccess().getPathFileParserRuleCall_1_0()); } | ||
8493 | ruleFile | ||
8494 | { after(grammarAccess.getFolderEntryAccess().getPathFileParserRuleCall_1_0()); } | ||
8495 | ) | ||
8496 | ; | ||
8497 | finally { | ||
8498 | restoreStackSize(stackSize); | ||
8499 | } | ||
8500 | |||
8501 | rule__FolderEntry__ExclusionAssignment_2_2 | ||
8502 | @init { | ||
8503 | int stackSize = keepStackSize(); | ||
8504 | } | ||
8505 | : | ||
8506 | ( | ||
8507 | { before(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_2_0()); } | ||
8508 | ruleModelEntry | ||
8509 | { after(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_2_0()); } | ||
8510 | ) | ||
8511 | ; | ||
8512 | finally { | ||
8513 | restoreStackSize(stackSize); | ||
8514 | } | ||
8515 | |||
8516 | rule__FolderEntry__ExclusionAssignment_2_3_1 | ||
8517 | @init { | ||
8518 | int stackSize = keepStackSize(); | ||
8519 | } | ||
8520 | : | ||
8521 | ( | ||
8522 | { before(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_3_1_0()); } | ||
8523 | ruleModelEntry | ||
8524 | { after(grammarAccess.getFolderEntryAccess().getExclusionModelEntryParserRuleCall_2_3_1_0()); } | ||
8525 | ) | ||
8526 | ; | ||
8527 | finally { | ||
8528 | restoreStackSize(stackSize); | ||
8529 | } | ||
8530 | |||
8531 | rule__PartialModelDeclaration__NameAssignment_1 | ||
8532 | @init { | ||
8533 | int stackSize = keepStackSize(); | ||
8534 | } | ||
8535 | : | ||
8536 | ( | ||
8537 | { before(grammarAccess.getPartialModelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } | ||
8538 | RULE_ID | ||
8539 | { after(grammarAccess.getPartialModelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } | ||
8540 | ) | ||
8541 | ; | ||
8542 | finally { | ||
8543 | restoreStackSize(stackSize); | ||
8544 | } | ||
8545 | |||
8546 | rule__PartialModelDeclaration__SpecificationAssignment_2 | ||
8547 | @init { | ||
8548 | int stackSize = keepStackSize(); | ||
8549 | } | ||
8550 | : | ||
8551 | ( | ||
8552 | { before(grammarAccess.getPartialModelDeclarationAccess().getSpecificationPartialModelSpecificationParserRuleCall_2_0()); } | ||
8553 | rulePartialModelSpecification | ||
8554 | { after(grammarAccess.getPartialModelDeclarationAccess().getSpecificationPartialModelSpecificationParserRuleCall_2_0()); } | ||
8555 | ) | ||
8556 | ; | ||
8557 | finally { | ||
8558 | restoreStackSize(stackSize); | ||
8559 | } | ||
8560 | |||
8561 | rule__PartialModelReference__ReferredAssignment | ||
8562 | @init { | ||
8563 | int stackSize = keepStackSize(); | ||
8564 | } | ||
8565 | : | ||
8566 | ( | ||
8567 | { before(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationCrossReference_0()); } | ||
8568 | ( | ||
8569 | { before(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationIDTerminalRuleCall_0_1()); } | ||
8570 | RULE_ID | ||
8571 | { after(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationIDTerminalRuleCall_0_1()); } | ||
8572 | ) | ||
8573 | { after(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationCrossReference_0()); } | ||
8574 | ) | ||
8575 | ; | ||
8576 | finally { | ||
8577 | restoreStackSize(stackSize); | ||
8578 | } | ||
8579 | |||
8580 | rule__PatternSpecification__EntriesAssignment_1 | ||
8581 | @init { | ||
8582 | int stackSize = keepStackSize(); | ||
8583 | } | ||
8584 | : | ||
8585 | ( | ||
8586 | { before(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_1_0()); } | ||
8587 | rulePatternEntry | ||
8588 | { after(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_1_0()); } | ||
8589 | ) | ||
8590 | ; | ||
8591 | finally { | ||
8592 | restoreStackSize(stackSize); | ||
8593 | } | ||
8594 | |||
8595 | rule__PatternSpecification__EntriesAssignment_2_1 | ||
8596 | @init { | ||
8597 | int stackSize = keepStackSize(); | ||
8598 | } | ||
8599 | : | ||
8600 | ( | ||
8601 | { before(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_2_1_0()); } | ||
8602 | rulePatternEntry | ||
8603 | { after(grammarAccess.getPatternSpecificationAccess().getEntriesPatternEntryParserRuleCall_2_1_0()); } | ||
8604 | ) | ||
8605 | ; | ||
8606 | finally { | ||
8607 | restoreStackSize(stackSize); | ||
8608 | } | ||
8609 | |||
8610 | rule__AllPatternEntry__PackageAssignment_1 | ||
8611 | @init { | ||
8612 | int stackSize = keepStackSize(); | ||
8613 | } | ||
8614 | : | ||
8615 | ( | ||
8616 | { before(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelCrossReference_1_0()); } | ||
8617 | ( | ||
8618 | { before(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelQualifiedNameParserRuleCall_1_0_1()); } | ||
8619 | ruleQualifiedName | ||
8620 | { after(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelQualifiedNameParserRuleCall_1_0_1()); } | ||
8621 | ) | ||
8622 | { after(grammarAccess.getAllPatternEntryAccess().getPackagePatternModelCrossReference_1_0()); } | ||
8623 | ) | ||
8624 | ; | ||
8625 | finally { | ||
8626 | restoreStackSize(stackSize); | ||
8627 | } | ||
8628 | |||
8629 | rule__AllPatternEntry__ExclusuionAssignment_2_2 | ||
8630 | @init { | ||
8631 | int stackSize = keepStackSize(); | ||
8632 | } | ||
8633 | : | ||
8634 | ( | ||
8635 | { before(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_2_0()); } | ||
8636 | rulePatternElement | ||
8637 | { after(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_2_0()); } | ||
8638 | ) | ||
8639 | ; | ||
8640 | finally { | ||
8641 | restoreStackSize(stackSize); | ||
8642 | } | ||
8643 | |||
8644 | rule__AllPatternEntry__ExclusuionAssignment_2_3_1 | ||
8645 | @init { | ||
8646 | int stackSize = keepStackSize(); | ||
8647 | } | ||
8648 | : | ||
8649 | ( | ||
8650 | { before(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_3_1_0()); } | ||
8651 | rulePatternElement | ||
8652 | { after(grammarAccess.getAllPatternEntryAccess().getExclusuionPatternElementParserRuleCall_2_3_1_0()); } | ||
8653 | ) | ||
8654 | ; | ||
8655 | finally { | ||
8656 | restoreStackSize(stackSize); | ||
8657 | } | ||
8658 | |||
8659 | rule__PatternElement__PackageAssignment_0_0 | ||
8660 | @init { | ||
8661 | int stackSize = keepStackSize(); | ||
8662 | } | ||
8663 | : | ||
8664 | ( | ||
8665 | { before(grammarAccess.getPatternElementAccess().getPackagePatternModelCrossReference_0_0_0()); } | ||
8666 | ( | ||
8667 | { before(grammarAccess.getPatternElementAccess().getPackagePatternModelQualifiedNameParserRuleCall_0_0_0_1()); } | ||
8668 | ruleQualifiedName | ||
8669 | { after(grammarAccess.getPatternElementAccess().getPackagePatternModelQualifiedNameParserRuleCall_0_0_0_1()); } | ||
8670 | ) | ||
8671 | { after(grammarAccess.getPatternElementAccess().getPackagePatternModelCrossReference_0_0_0()); } | ||
8672 | ) | ||
8673 | ; | ||
8674 | finally { | ||
8675 | restoreStackSize(stackSize); | ||
8676 | } | ||
8677 | |||
8678 | rule__PatternElement__PatternAssignment_1 | ||
8679 | @init { | ||
8680 | int stackSize = keepStackSize(); | ||
8681 | } | ||
8682 | : | ||
8683 | ( | ||
8684 | { before(grammarAccess.getPatternElementAccess().getPatternPatternCrossReference_1_0()); } | ||
8685 | ( | ||
8686 | { before(grammarAccess.getPatternElementAccess().getPatternPatternIDTerminalRuleCall_1_0_1()); } | ||
8687 | RULE_ID | ||
8688 | { after(grammarAccess.getPatternElementAccess().getPatternPatternIDTerminalRuleCall_1_0_1()); } | ||
8689 | ) | ||
8690 | { after(grammarAccess.getPatternElementAccess().getPatternPatternCrossReference_1_0()); } | ||
8691 | ) | ||
8692 | ; | ||
8693 | finally { | ||
8694 | restoreStackSize(stackSize); | ||
8695 | } | ||
8696 | |||
8697 | rule__GraphPatternDeclaration__NameAssignment_1 | ||
8698 | @init { | ||
8699 | int stackSize = keepStackSize(); | ||
8700 | } | ||
8701 | : | ||
8702 | ( | ||
8703 | { before(grammarAccess.getGraphPatternDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } | ||
8704 | RULE_ID | ||
8705 | { after(grammarAccess.getGraphPatternDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } | ||
8706 | ) | ||
8707 | ; | ||
8708 | finally { | ||
8709 | restoreStackSize(stackSize); | ||
8710 | } | ||
8711 | |||
8712 | rule__GraphPatternDeclaration__SpecificationAssignment_2 | ||
8713 | @init { | ||
8714 | int stackSize = keepStackSize(); | ||
8715 | } | ||
8716 | : | ||
8717 | ( | ||
8718 | { before(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationPatternSpecificationParserRuleCall_2_0()); } | ||
8719 | rulePatternSpecification | ||
8720 | { after(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationPatternSpecificationParserRuleCall_2_0()); } | ||
8721 | ) | ||
8722 | ; | ||
8723 | finally { | ||
8724 | restoreStackSize(stackSize); | ||
8725 | } | ||
8726 | |||
8727 | rule__GraphPatternReference__ReferredAssignment | ||
8728 | @init { | ||
8729 | int stackSize = keepStackSize(); | ||
8730 | } | ||
8731 | : | ||
8732 | ( | ||
8733 | { before(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationCrossReference_0()); } | ||
8734 | ( | ||
8735 | { before(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationIDTerminalRuleCall_0_1()); } | ||
8736 | RULE_ID | ||
8737 | { after(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationIDTerminalRuleCall_0_1()); } | ||
8738 | ) | ||
8739 | { after(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationCrossReference_0()); } | ||
8740 | ) | ||
8741 | ; | ||
8742 | finally { | ||
8743 | restoreStackSize(stackSize); | ||
8744 | } | ||
8745 | |||
8746 | rule__ConfigSpecification__EntriesAssignment_2_0 | ||
8747 | @init { | ||
8748 | int stackSize = keepStackSize(); | ||
8749 | } | ||
8750 | : | ||
8751 | ( | ||
8752 | { before(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_0_0()); } | ||
8753 | ruleConfigEntry | ||
8754 | { after(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_0_0()); } | ||
8755 | ) | ||
8756 | ; | ||
8757 | finally { | ||
8758 | restoreStackSize(stackSize); | ||
8759 | } | ||
8760 | |||
8761 | rule__ConfigSpecification__EntriesAssignment_2_1_1 | ||
8762 | @init { | ||
8763 | int stackSize = keepStackSize(); | ||
8764 | } | ||
8765 | : | ||
8766 | ( | ||
8767 | { before(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_1_1_0()); } | ||
8768 | ruleConfigEntry | ||
8769 | { after(grammarAccess.getConfigSpecificationAccess().getEntriesConfigEntryParserRuleCall_2_1_1_0()); } | ||
8770 | ) | ||
8771 | ; | ||
8772 | finally { | ||
8773 | restoreStackSize(stackSize); | ||
8774 | } | ||
8775 | |||
8776 | rule__ConfigDeclaration__NameAssignment_1 | ||
8777 | @init { | ||
8778 | int stackSize = keepStackSize(); | ||
8779 | } | ||
8780 | : | ||
8781 | ( | ||
8782 | { before(grammarAccess.getConfigDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } | ||
8783 | RULE_ID | ||
8784 | { after(grammarAccess.getConfigDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } | ||
8785 | ) | ||
8786 | ; | ||
8787 | finally { | ||
8788 | restoreStackSize(stackSize); | ||
8789 | } | ||
8790 | |||
8791 | rule__ConfigDeclaration__SpecificationAssignment_2 | ||
8792 | @init { | ||
8793 | int stackSize = keepStackSize(); | ||
8794 | } | ||
8795 | : | ||
8796 | ( | ||
8797 | { before(grammarAccess.getConfigDeclarationAccess().getSpecificationConfigSpecificationParserRuleCall_2_0()); } | ||
8798 | ruleConfigSpecification | ||
8799 | { after(grammarAccess.getConfigDeclarationAccess().getSpecificationConfigSpecificationParserRuleCall_2_0()); } | ||
8800 | ) | ||
8801 | ; | ||
8802 | finally { | ||
8803 | restoreStackSize(stackSize); | ||
8804 | } | ||
8805 | |||
8806 | rule__ConfigEntry__KeyAssignment_0 | ||
8807 | @init { | ||
8808 | int stackSize = keepStackSize(); | ||
8809 | } | ||
8810 | : | ||
8811 | ( | ||
8812 | { before(grammarAccess.getConfigEntryAccess().getKeySTRINGTerminalRuleCall_0_0()); } | ||
8813 | RULE_STRING | ||
8814 | { after(grammarAccess.getConfigEntryAccess().getKeySTRINGTerminalRuleCall_0_0()); } | ||
8815 | ) | ||
8816 | ; | ||
8817 | finally { | ||
8818 | restoreStackSize(stackSize); | ||
8819 | } | ||
8820 | |||
8821 | rule__ConfigEntry__ValueAssignment_2 | ||
8822 | @init { | ||
8823 | int stackSize = keepStackSize(); | ||
8824 | } | ||
8825 | : | ||
8826 | ( | ||
8827 | { before(grammarAccess.getConfigEntryAccess().getValueSTRINGTerminalRuleCall_2_0()); } | ||
8828 | RULE_STRING | ||
8829 | { after(grammarAccess.getConfigEntryAccess().getValueSTRINGTerminalRuleCall_2_0()); } | ||
8830 | ) | ||
8831 | ; | ||
8832 | finally { | ||
8833 | restoreStackSize(stackSize); | ||
8834 | } | ||
8835 | |||
8836 | rule__ConfigReference__ConfigAssignment | ||
8837 | @init { | ||
8838 | int stackSize = keepStackSize(); | ||
8839 | } | ||
8840 | : | ||
8841 | ( | ||
8842 | { before(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationCrossReference_0()); } | ||
8843 | ( | ||
8844 | { before(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationIDTerminalRuleCall_0_1()); } | ||
8845 | RULE_ID | ||
8846 | { after(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationIDTerminalRuleCall_0_1()); } | ||
8847 | ) | ||
8848 | { after(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationCrossReference_0()); } | ||
8849 | ) | ||
8850 | ; | ||
8851 | finally { | ||
8852 | restoreStackSize(stackSize); | ||
8853 | } | ||
8854 | |||
8855 | rule__ScopeSpecification__ScopesAssignment_2_0 | ||
8856 | @init { | ||
8857 | int stackSize = keepStackSize(); | ||
8858 | } | ||
8859 | : | ||
8860 | ( | ||
8861 | { before(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_0_0()); } | ||
8862 | ruleTypeScope | ||
8863 | { after(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_0_0()); } | ||
8864 | ) | ||
8865 | ; | ||
8866 | finally { | ||
8867 | restoreStackSize(stackSize); | ||
8868 | } | ||
8869 | |||
8870 | rule__ScopeSpecification__ScopesAssignment_2_1_1 | ||
8871 | @init { | ||
8872 | int stackSize = keepStackSize(); | ||
8873 | } | ||
8874 | : | ||
8875 | ( | ||
8876 | { before(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_1_1_0()); } | ||
8877 | ruleTypeScope | ||
8878 | { after(grammarAccess.getScopeSpecificationAccess().getScopesTypeScopeParserRuleCall_2_1_1_0()); } | ||
8879 | ) | ||
8880 | ; | ||
8881 | finally { | ||
8882 | restoreStackSize(stackSize); | ||
8883 | } | ||
8884 | |||
8885 | rule__ClassTypeScope__TypeAssignment_1 | ||
8886 | @init { | ||
8887 | int stackSize = keepStackSize(); | ||
8888 | } | ||
8889 | : | ||
8890 | ( | ||
8891 | { before(grammarAccess.getClassTypeScopeAccess().getTypeClassReferenceParserRuleCall_1_0()); } | ||
8892 | ruleClassReference | ||
8893 | { after(grammarAccess.getClassTypeScopeAccess().getTypeClassReferenceParserRuleCall_1_0()); } | ||
8894 | ) | ||
8895 | ; | ||
8896 | finally { | ||
8897 | restoreStackSize(stackSize); | ||
8898 | } | ||
8899 | |||
8900 | rule__ClassTypeScope__SetsNewAssignment_2_0 | ||
8901 | @init { | ||
8902 | int stackSize = keepStackSize(); | ||
8903 | } | ||
8904 | : | ||
8905 | ( | ||
8906 | { before(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
8907 | ( | ||
8908 | { before(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
8909 | '+=' | ||
8910 | { after(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
8911 | ) | ||
8912 | { after(grammarAccess.getClassTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
8913 | ) | ||
8914 | ; | ||
8915 | finally { | ||
8916 | restoreStackSize(stackSize); | ||
8917 | } | ||
8918 | |||
8919 | rule__ClassTypeScope__SetsSumAssignment_2_1 | ||
8920 | @init { | ||
8921 | int stackSize = keepStackSize(); | ||
8922 | } | ||
8923 | : | ||
8924 | ( | ||
8925 | { before(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
8926 | ( | ||
8927 | { before(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
8928 | '=' | ||
8929 | { after(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
8930 | ) | ||
8931 | { after(grammarAccess.getClassTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
8932 | ) | ||
8933 | ; | ||
8934 | finally { | ||
8935 | restoreStackSize(stackSize); | ||
8936 | } | ||
8937 | |||
8938 | rule__ClassTypeScope__NumberAssignment_3_0 | ||
8939 | @init { | ||
8940 | int stackSize = keepStackSize(); | ||
8941 | } | ||
8942 | : | ||
8943 | ( | ||
8944 | { before(grammarAccess.getClassTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } | ||
8945 | ruleExactNumber | ||
8946 | { after(grammarAccess.getClassTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } | ||
8947 | ) | ||
8948 | ; | ||
8949 | finally { | ||
8950 | restoreStackSize(stackSize); | ||
8951 | } | ||
8952 | |||
8953 | rule__ClassTypeScope__NumberAssignment_3_1 | ||
8954 | @init { | ||
8955 | int stackSize = keepStackSize(); | ||
8956 | } | ||
8957 | : | ||
8958 | ( | ||
8959 | { before(grammarAccess.getClassTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } | ||
8960 | ruleIntervallNumber | ||
8961 | { after(grammarAccess.getClassTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } | ||
8962 | ) | ||
8963 | ; | ||
8964 | finally { | ||
8965 | restoreStackSize(stackSize); | ||
8966 | } | ||
8967 | |||
8968 | rule__ObjectTypeScope__TypeAssignment_1 | ||
8969 | @init { | ||
8970 | int stackSize = keepStackSize(); | ||
8971 | } | ||
8972 | : | ||
8973 | ( | ||
8974 | { before(grammarAccess.getObjectTypeScopeAccess().getTypeObjectReferenceParserRuleCall_1_0()); } | ||
8975 | ruleObjectReference | ||
8976 | { after(grammarAccess.getObjectTypeScopeAccess().getTypeObjectReferenceParserRuleCall_1_0()); } | ||
8977 | ) | ||
8978 | ; | ||
8979 | finally { | ||
8980 | restoreStackSize(stackSize); | ||
8981 | } | ||
8982 | |||
8983 | rule__ObjectTypeScope__SetsNewAssignment_2_0 | ||
8984 | @init { | ||
8985 | int stackSize = keepStackSize(); | ||
8986 | } | ||
8987 | : | ||
8988 | ( | ||
8989 | { before(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
8990 | ( | ||
8991 | { before(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
8992 | '+=' | ||
8993 | { after(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
8994 | ) | ||
8995 | { after(grammarAccess.getObjectTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
8996 | ) | ||
8997 | ; | ||
8998 | finally { | ||
8999 | restoreStackSize(stackSize); | ||
9000 | } | ||
9001 | |||
9002 | rule__ObjectTypeScope__SetsSumAssignment_2_1 | ||
9003 | @init { | ||
9004 | int stackSize = keepStackSize(); | ||
9005 | } | ||
9006 | : | ||
9007 | ( | ||
9008 | { before(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9009 | ( | ||
9010 | { before(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9011 | '=' | ||
9012 | { after(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9013 | ) | ||
9014 | { after(grammarAccess.getObjectTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9015 | ) | ||
9016 | ; | ||
9017 | finally { | ||
9018 | restoreStackSize(stackSize); | ||
9019 | } | ||
9020 | |||
9021 | rule__ObjectTypeScope__NumberAssignment_3_0 | ||
9022 | @init { | ||
9023 | int stackSize = keepStackSize(); | ||
9024 | } | ||
9025 | : | ||
9026 | ( | ||
9027 | { before(grammarAccess.getObjectTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } | ||
9028 | ruleExactNumber | ||
9029 | { after(grammarAccess.getObjectTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } | ||
9030 | ) | ||
9031 | ; | ||
9032 | finally { | ||
9033 | restoreStackSize(stackSize); | ||
9034 | } | ||
9035 | |||
9036 | rule__ObjectTypeScope__NumberAssignment_3_1 | ||
9037 | @init { | ||
9038 | int stackSize = keepStackSize(); | ||
9039 | } | ||
9040 | : | ||
9041 | ( | ||
9042 | { before(grammarAccess.getObjectTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } | ||
9043 | ruleIntervallNumber | ||
9044 | { after(grammarAccess.getObjectTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } | ||
9045 | ) | ||
9046 | ; | ||
9047 | finally { | ||
9048 | restoreStackSize(stackSize); | ||
9049 | } | ||
9050 | |||
9051 | rule__IntegerTypeScope__TypeAssignment_1 | ||
9052 | @init { | ||
9053 | int stackSize = keepStackSize(); | ||
9054 | } | ||
9055 | : | ||
9056 | ( | ||
9057 | { before(grammarAccess.getIntegerTypeScopeAccess().getTypeIntegerReferenceParserRuleCall_1_0()); } | ||
9058 | ruleIntegerReference | ||
9059 | { after(grammarAccess.getIntegerTypeScopeAccess().getTypeIntegerReferenceParserRuleCall_1_0()); } | ||
9060 | ) | ||
9061 | ; | ||
9062 | finally { | ||
9063 | restoreStackSize(stackSize); | ||
9064 | } | ||
9065 | |||
9066 | rule__IntegerTypeScope__SetsNewAssignment_2_0 | ||
9067 | @init { | ||
9068 | int stackSize = keepStackSize(); | ||
9069 | } | ||
9070 | : | ||
9071 | ( | ||
9072 | { before(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9073 | ( | ||
9074 | { before(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9075 | '+=' | ||
9076 | { after(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9077 | ) | ||
9078 | { after(grammarAccess.getIntegerTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9079 | ) | ||
9080 | ; | ||
9081 | finally { | ||
9082 | restoreStackSize(stackSize); | ||
9083 | } | ||
9084 | |||
9085 | rule__IntegerTypeScope__SetsSumAssignment_2_1 | ||
9086 | @init { | ||
9087 | int stackSize = keepStackSize(); | ||
9088 | } | ||
9089 | : | ||
9090 | ( | ||
9091 | { before(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9092 | ( | ||
9093 | { before(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9094 | '=' | ||
9095 | { after(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9096 | ) | ||
9097 | { after(grammarAccess.getIntegerTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9098 | ) | ||
9099 | ; | ||
9100 | finally { | ||
9101 | restoreStackSize(stackSize); | ||
9102 | } | ||
9103 | |||
9104 | rule__IntegerTypeScope__NumberAssignment_3_0 | ||
9105 | @init { | ||
9106 | int stackSize = keepStackSize(); | ||
9107 | } | ||
9108 | : | ||
9109 | ( | ||
9110 | { before(grammarAccess.getIntegerTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } | ||
9111 | ruleExactNumber | ||
9112 | { after(grammarAccess.getIntegerTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } | ||
9113 | ) | ||
9114 | ; | ||
9115 | finally { | ||
9116 | restoreStackSize(stackSize); | ||
9117 | } | ||
9118 | |||
9119 | rule__IntegerTypeScope__NumberAssignment_3_1 | ||
9120 | @init { | ||
9121 | int stackSize = keepStackSize(); | ||
9122 | } | ||
9123 | : | ||
9124 | ( | ||
9125 | { before(grammarAccess.getIntegerTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } | ||
9126 | ruleIntervallNumber | ||
9127 | { after(grammarAccess.getIntegerTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } | ||
9128 | ) | ||
9129 | ; | ||
9130 | finally { | ||
9131 | restoreStackSize(stackSize); | ||
9132 | } | ||
9133 | |||
9134 | rule__IntegerTypeScope__NumberAssignment_3_2 | ||
9135 | @init { | ||
9136 | int stackSize = keepStackSize(); | ||
9137 | } | ||
9138 | : | ||
9139 | ( | ||
9140 | { before(grammarAccess.getIntegerTypeScopeAccess().getNumberIntEnumberationParserRuleCall_3_2_0()); } | ||
9141 | ruleIntEnumberation | ||
9142 | { after(grammarAccess.getIntegerTypeScopeAccess().getNumberIntEnumberationParserRuleCall_3_2_0()); } | ||
9143 | ) | ||
9144 | ; | ||
9145 | finally { | ||
9146 | restoreStackSize(stackSize); | ||
9147 | } | ||
9148 | |||
9149 | rule__RealTypeScope__TypeAssignment_1 | ||
9150 | @init { | ||
9151 | int stackSize = keepStackSize(); | ||
9152 | } | ||
9153 | : | ||
9154 | ( | ||
9155 | { before(grammarAccess.getRealTypeScopeAccess().getTypeRealReferenceParserRuleCall_1_0()); } | ||
9156 | ruleRealReference | ||
9157 | { after(grammarAccess.getRealTypeScopeAccess().getTypeRealReferenceParserRuleCall_1_0()); } | ||
9158 | ) | ||
9159 | ; | ||
9160 | finally { | ||
9161 | restoreStackSize(stackSize); | ||
9162 | } | ||
9163 | |||
9164 | rule__RealTypeScope__SetsNewAssignment_2_0 | ||
9165 | @init { | ||
9166 | int stackSize = keepStackSize(); | ||
9167 | } | ||
9168 | : | ||
9169 | ( | ||
9170 | { before(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9171 | ( | ||
9172 | { before(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9173 | '+=' | ||
9174 | { after(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9175 | ) | ||
9176 | { after(grammarAccess.getRealTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9177 | ) | ||
9178 | ; | ||
9179 | finally { | ||
9180 | restoreStackSize(stackSize); | ||
9181 | } | ||
9182 | |||
9183 | rule__RealTypeScope__SetsSumAssignment_2_1 | ||
9184 | @init { | ||
9185 | int stackSize = keepStackSize(); | ||
9186 | } | ||
9187 | : | ||
9188 | ( | ||
9189 | { before(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9190 | ( | ||
9191 | { before(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9192 | '=' | ||
9193 | { after(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9194 | ) | ||
9195 | { after(grammarAccess.getRealTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9196 | ) | ||
9197 | ; | ||
9198 | finally { | ||
9199 | restoreStackSize(stackSize); | ||
9200 | } | ||
9201 | |||
9202 | rule__RealTypeScope__NumberAssignment_3_0 | ||
9203 | @init { | ||
9204 | int stackSize = keepStackSize(); | ||
9205 | } | ||
9206 | : | ||
9207 | ( | ||
9208 | { before(grammarAccess.getRealTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } | ||
9209 | ruleExactNumber | ||
9210 | { after(grammarAccess.getRealTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } | ||
9211 | ) | ||
9212 | ; | ||
9213 | finally { | ||
9214 | restoreStackSize(stackSize); | ||
9215 | } | ||
9216 | |||
9217 | rule__RealTypeScope__NumberAssignment_3_1 | ||
9218 | @init { | ||
9219 | int stackSize = keepStackSize(); | ||
9220 | } | ||
9221 | : | ||
9222 | ( | ||
9223 | { before(grammarAccess.getRealTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } | ||
9224 | ruleIntervallNumber | ||
9225 | { after(grammarAccess.getRealTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } | ||
9226 | ) | ||
9227 | ; | ||
9228 | finally { | ||
9229 | restoreStackSize(stackSize); | ||
9230 | } | ||
9231 | |||
9232 | rule__RealTypeScope__NumberAssignment_3_2 | ||
9233 | @init { | ||
9234 | int stackSize = keepStackSize(); | ||
9235 | } | ||
9236 | : | ||
9237 | ( | ||
9238 | { before(grammarAccess.getRealTypeScopeAccess().getNumberRealEnumerationParserRuleCall_3_2_0()); } | ||
9239 | ruleRealEnumeration | ||
9240 | { after(grammarAccess.getRealTypeScopeAccess().getNumberRealEnumerationParserRuleCall_3_2_0()); } | ||
9241 | ) | ||
9242 | ; | ||
9243 | finally { | ||
9244 | restoreStackSize(stackSize); | ||
9245 | } | ||
9246 | |||
9247 | rule__StringTypeScope__TypeAssignment_1 | ||
9248 | @init { | ||
9249 | int stackSize = keepStackSize(); | ||
9250 | } | ||
9251 | : | ||
9252 | ( | ||
9253 | { before(grammarAccess.getStringTypeScopeAccess().getTypeStringReferenceParserRuleCall_1_0()); } | ||
9254 | ruleStringReference | ||
9255 | { after(grammarAccess.getStringTypeScopeAccess().getTypeStringReferenceParserRuleCall_1_0()); } | ||
9256 | ) | ||
9257 | ; | ||
9258 | finally { | ||
9259 | restoreStackSize(stackSize); | ||
9260 | } | ||
9261 | |||
9262 | rule__StringTypeScope__SetsNewAssignment_2_0 | ||
9263 | @init { | ||
9264 | int stackSize = keepStackSize(); | ||
9265 | } | ||
9266 | : | ||
9267 | ( | ||
9268 | { before(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9269 | ( | ||
9270 | { before(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9271 | '+=' | ||
9272 | { after(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9273 | ) | ||
9274 | { after(grammarAccess.getStringTypeScopeAccess().getSetsNewPlusSignEqualsSignKeyword_2_0_0()); } | ||
9275 | ) | ||
9276 | ; | ||
9277 | finally { | ||
9278 | restoreStackSize(stackSize); | ||
9279 | } | ||
9280 | |||
9281 | rule__StringTypeScope__SetsSumAssignment_2_1 | ||
9282 | @init { | ||
9283 | int stackSize = keepStackSize(); | ||
9284 | } | ||
9285 | : | ||
9286 | ( | ||
9287 | { before(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9288 | ( | ||
9289 | { before(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9290 | '=' | ||
9291 | { after(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9292 | ) | ||
9293 | { after(grammarAccess.getStringTypeScopeAccess().getSetsSumEqualsSignKeyword_2_1_0()); } | ||
9294 | ) | ||
9295 | ; | ||
9296 | finally { | ||
9297 | restoreStackSize(stackSize); | ||
9298 | } | ||
9299 | |||
9300 | rule__StringTypeScope__NumberAssignment_3_0 | ||
9301 | @init { | ||
9302 | int stackSize = keepStackSize(); | ||
9303 | } | ||
9304 | : | ||
9305 | ( | ||
9306 | { before(grammarAccess.getStringTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } | ||
9307 | ruleExactNumber | ||
9308 | { after(grammarAccess.getStringTypeScopeAccess().getNumberExactNumberParserRuleCall_3_0_0()); } | ||
9309 | ) | ||
9310 | ; | ||
9311 | finally { | ||
9312 | restoreStackSize(stackSize); | ||
9313 | } | ||
9314 | |||
9315 | rule__StringTypeScope__NumberAssignment_3_1 | ||
9316 | @init { | ||
9317 | int stackSize = keepStackSize(); | ||
9318 | } | ||
9319 | : | ||
9320 | ( | ||
9321 | { before(grammarAccess.getStringTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } | ||
9322 | ruleIntervallNumber | ||
9323 | { after(grammarAccess.getStringTypeScopeAccess().getNumberIntervallNumberParserRuleCall_3_1_0()); } | ||
9324 | ) | ||
9325 | ; | ||
9326 | finally { | ||
9327 | restoreStackSize(stackSize); | ||
9328 | } | ||
9329 | |||
9330 | rule__StringTypeScope__NumberAssignment_3_2 | ||
9331 | @init { | ||
9332 | int stackSize = keepStackSize(); | ||
9333 | } | ||
9334 | : | ||
9335 | ( | ||
9336 | { before(grammarAccess.getStringTypeScopeAccess().getNumberStringEnumerationParserRuleCall_3_2_0()); } | ||
9337 | ruleStringEnumeration | ||
9338 | { after(grammarAccess.getStringTypeScopeAccess().getNumberStringEnumerationParserRuleCall_3_2_0()); } | ||
9339 | ) | ||
9340 | ; | ||
9341 | finally { | ||
9342 | restoreStackSize(stackSize); | ||
9343 | } | ||
9344 | |||
9345 | rule__ClassReference__ElementAssignment_1 | ||
9346 | @init { | ||
9347 | int stackSize = keepStackSize(); | ||
9348 | } | ||
9349 | : | ||
9350 | ( | ||
9351 | { before(grammarAccess.getClassReferenceAccess().getElementMetamodelElementParserRuleCall_1_0()); } | ||
9352 | ruleMetamodelElement | ||
9353 | { after(grammarAccess.getClassReferenceAccess().getElementMetamodelElementParserRuleCall_1_0()); } | ||
9354 | ) | ||
9355 | ; | ||
9356 | finally { | ||
9357 | restoreStackSize(stackSize); | ||
9358 | } | ||
9359 | |||
9360 | rule__ExactNumber__ExactNumberAssignment_0 | ||
9361 | @init { | ||
9362 | int stackSize = keepStackSize(); | ||
9363 | } | ||
9364 | : | ||
9365 | ( | ||
9366 | { before(grammarAccess.getExactNumberAccess().getExactNumberINTTerminalRuleCall_0_0()); } | ||
9367 | RULE_INT | ||
9368 | { after(grammarAccess.getExactNumberAccess().getExactNumberINTTerminalRuleCall_0_0()); } | ||
9369 | ) | ||
9370 | ; | ||
9371 | finally { | ||
9372 | restoreStackSize(stackSize); | ||
9373 | } | ||
9374 | |||
9375 | rule__ExactNumber__ExactUnlimitedAssignment_1 | ||
9376 | @init { | ||
9377 | int stackSize = keepStackSize(); | ||
9378 | } | ||
9379 | : | ||
9380 | ( | ||
9381 | { before(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); } | ||
9382 | ( | ||
9383 | { before(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); } | ||
9384 | '*' | ||
9385 | { after(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); } | ||
9386 | ) | ||
9387 | { after(grammarAccess.getExactNumberAccess().getExactUnlimitedAsteriskKeyword_1_0()); } | ||
9388 | ) | ||
9389 | ; | ||
9390 | finally { | ||
9391 | restoreStackSize(stackSize); | ||
9392 | } | ||
9393 | |||
9394 | rule__IntervallNumber__MinAssignment_0 | ||
9395 | @init { | ||
9396 | int stackSize = keepStackSize(); | ||
9397 | } | ||
9398 | : | ||
9399 | ( | ||
9400 | { before(grammarAccess.getIntervallNumberAccess().getMinINTTerminalRuleCall_0_0()); } | ||
9401 | RULE_INT | ||
9402 | { after(grammarAccess.getIntervallNumberAccess().getMinINTTerminalRuleCall_0_0()); } | ||
9403 | ) | ||
9404 | ; | ||
9405 | finally { | ||
9406 | restoreStackSize(stackSize); | ||
9407 | } | ||
9408 | |||
9409 | rule__IntervallNumber__MaxNumberAssignment_2_0 | ||
9410 | @init { | ||
9411 | int stackSize = keepStackSize(); | ||
9412 | } | ||
9413 | : | ||
9414 | ( | ||
9415 | { before(grammarAccess.getIntervallNumberAccess().getMaxNumberINTTerminalRuleCall_2_0_0()); } | ||
9416 | RULE_INT | ||
9417 | { after(grammarAccess.getIntervallNumberAccess().getMaxNumberINTTerminalRuleCall_2_0_0()); } | ||
9418 | ) | ||
9419 | ; | ||
9420 | finally { | ||
9421 | restoreStackSize(stackSize); | ||
9422 | } | ||
9423 | |||
9424 | rule__IntervallNumber__MaxUnlimitedAssignment_2_1 | ||
9425 | @init { | ||
9426 | int stackSize = keepStackSize(); | ||
9427 | } | ||
9428 | : | ||
9429 | ( | ||
9430 | { before(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); } | ||
9431 | ( | ||
9432 | { before(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); } | ||
9433 | '*' | ||
9434 | { after(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); } | ||
9435 | ) | ||
9436 | { after(grammarAccess.getIntervallNumberAccess().getMaxUnlimitedAsteriskKeyword_2_1_0()); } | ||
9437 | ) | ||
9438 | ; | ||
9439 | finally { | ||
9440 | restoreStackSize(stackSize); | ||
9441 | } | ||
9442 | |||
9443 | rule__IntEnumberation__EntryAssignment_2_0 | ||
9444 | @init { | ||
9445 | int stackSize = keepStackSize(); | ||
9446 | } | ||
9447 | : | ||
9448 | ( | ||
9449 | { before(grammarAccess.getIntEnumberationAccess().getEntryINTTerminalRuleCall_2_0_0()); } | ||
9450 | RULE_INT | ||
9451 | { after(grammarAccess.getIntEnumberationAccess().getEntryINTTerminalRuleCall_2_0_0()); } | ||
9452 | ) | ||
9453 | ; | ||
9454 | finally { | ||
9455 | restoreStackSize(stackSize); | ||
9456 | } | ||
9457 | |||
9458 | rule__IntEnumberation__EntryAssignment_2_1_1 | ||
9459 | @init { | ||
9460 | int stackSize = keepStackSize(); | ||
9461 | } | ||
9462 | : | ||
9463 | ( | ||
9464 | { before(grammarAccess.getIntEnumberationAccess().getEntryINTTerminalRuleCall_2_1_1_0()); } | ||
9465 | RULE_INT | ||
9466 | { after(grammarAccess.getIntEnumberationAccess().getEntryINTTerminalRuleCall_2_1_1_0()); } | ||
9467 | ) | ||
9468 | ; | ||
9469 | finally { | ||
9470 | restoreStackSize(stackSize); | ||
9471 | } | ||
9472 | |||
9473 | rule__RealEnumeration__EntryAssignment_2_0 | ||
9474 | @init { | ||
9475 | int stackSize = keepStackSize(); | ||
9476 | } | ||
9477 | : | ||
9478 | ( | ||
9479 | { before(grammarAccess.getRealEnumerationAccess().getEntryINTTerminalRuleCall_2_0_0()); } | ||
9480 | RULE_INT | ||
9481 | { after(grammarAccess.getRealEnumerationAccess().getEntryINTTerminalRuleCall_2_0_0()); } | ||
9482 | ) | ||
9483 | ; | ||
9484 | finally { | ||
9485 | restoreStackSize(stackSize); | ||
9486 | } | ||
9487 | |||
9488 | rule__RealEnumeration__EntryAssignment_2_1_1 | ||
9489 | @init { | ||
9490 | int stackSize = keepStackSize(); | ||
9491 | } | ||
9492 | : | ||
9493 | ( | ||
9494 | { before(grammarAccess.getRealEnumerationAccess().getEntryINTTerminalRuleCall_2_1_1_0()); } | ||
9495 | RULE_INT | ||
9496 | { after(grammarAccess.getRealEnumerationAccess().getEntryINTTerminalRuleCall_2_1_1_0()); } | ||
9497 | ) | ||
9498 | ; | ||
9499 | finally { | ||
9500 | restoreStackSize(stackSize); | ||
9501 | } | ||
9502 | |||
9503 | rule__StringEnumeration__EntryAssignment_2_0 | ||
9504 | @init { | ||
9505 | int stackSize = keepStackSize(); | ||
9506 | } | ||
9507 | : | ||
9508 | ( | ||
9509 | { before(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_0_0()); } | ||
9510 | RULE_STRING | ||
9511 | { after(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_0_0()); } | ||
9512 | ) | ||
9513 | ; | ||
9514 | finally { | ||
9515 | restoreStackSize(stackSize); | ||
9516 | } | ||
9517 | |||
9518 | rule__StringEnumeration__EntryAssignment_2_1_1 | ||
9519 | @init { | ||
9520 | int stackSize = keepStackSize(); | ||
9521 | } | ||
9522 | : | ||
9523 | ( | ||
9524 | { before(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_1_1_0()); } | ||
9525 | RULE_STRING | ||
9526 | { after(grammarAccess.getStringEnumerationAccess().getEntrySTRINGTerminalRuleCall_2_1_1_0()); } | ||
9527 | ) | ||
9528 | ; | ||
9529 | finally { | ||
9530 | restoreStackSize(stackSize); | ||
9531 | } | ||
9532 | |||
9533 | rule__ScopeDeclaration__NameAssignment_1 | ||
9534 | @init { | ||
9535 | int stackSize = keepStackSize(); | ||
9536 | } | ||
9537 | : | ||
9538 | ( | ||
9539 | { before(grammarAccess.getScopeDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } | ||
9540 | RULE_ID | ||
9541 | { after(grammarAccess.getScopeDeclarationAccess().getNameIDTerminalRuleCall_1_0()); } | ||
9542 | ) | ||
9543 | ; | ||
9544 | finally { | ||
9545 | restoreStackSize(stackSize); | ||
9546 | } | ||
9547 | |||
9548 | rule__ScopeDeclaration__SpecificationAssignment_2 | ||
9549 | @init { | ||
9550 | int stackSize = keepStackSize(); | ||
9551 | } | ||
9552 | : | ||
9553 | ( | ||
9554 | { before(grammarAccess.getScopeDeclarationAccess().getSpecificationScopeSpecificationParserRuleCall_2_0()); } | ||
9555 | ruleScopeSpecification | ||
9556 | { after(grammarAccess.getScopeDeclarationAccess().getSpecificationScopeSpecificationParserRuleCall_2_0()); } | ||
9557 | ) | ||
9558 | ; | ||
9559 | finally { | ||
9560 | restoreStackSize(stackSize); | ||
9561 | } | ||
9562 | |||
9563 | rule__ScopeReference__ReferredAssignment | ||
9564 | @init { | ||
9565 | int stackSize = keepStackSize(); | ||
9566 | } | ||
9567 | : | ||
9568 | ( | ||
9569 | { before(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationCrossReference_0()); } | ||
9570 | ( | ||
9571 | { before(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationIDTerminalRuleCall_0_1()); } | ||
9572 | RULE_ID | ||
9573 | { after(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationIDTerminalRuleCall_0_1()); } | ||
9574 | ) | ||
9575 | { after(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationCrossReference_0()); } | ||
9576 | ) | ||
9577 | ; | ||
9578 | finally { | ||
9579 | restoreStackSize(stackSize); | ||
9580 | } | ||
9581 | |||
9582 | rule__GenerationTask__MetamodelAssignment_3_0_2 | ||
9583 | @init { | ||
9584 | int stackSize = keepStackSize(); | ||
9585 | } | ||
9586 | : | ||
9587 | ( | ||
9588 | { before(grammarAccess.getGenerationTaskAccess().getMetamodelMetamodelParserRuleCall_3_0_2_0()); } | ||
9589 | ruleMetamodel | ||
9590 | { after(grammarAccess.getGenerationTaskAccess().getMetamodelMetamodelParserRuleCall_3_0_2_0()); } | ||
9591 | ) | ||
9592 | ; | ||
9593 | finally { | ||
9594 | restoreStackSize(stackSize); | ||
9595 | } | ||
9596 | |||
9597 | rule__GenerationTask__PartialModelAssignment_3_1_2 | ||
9598 | @init { | ||
9599 | int stackSize = keepStackSize(); | ||
9600 | } | ||
9601 | : | ||
9602 | ( | ||
9603 | { before(grammarAccess.getGenerationTaskAccess().getPartialModelPartialModelParserRuleCall_3_1_2_0()); } | ||
9604 | rulePartialModel | ||
9605 | { after(grammarAccess.getGenerationTaskAccess().getPartialModelPartialModelParserRuleCall_3_1_2_0()); } | ||
9606 | ) | ||
9607 | ; | ||
9608 | finally { | ||
9609 | restoreStackSize(stackSize); | ||
9610 | } | ||
9611 | |||
9612 | rule__GenerationTask__PatternsAssignment_3_2_2 | ||
9613 | @init { | ||
9614 | int stackSize = keepStackSize(); | ||
9615 | } | ||
9616 | : | ||
9617 | ( | ||
9618 | { before(grammarAccess.getGenerationTaskAccess().getPatternsGraphPatternParserRuleCall_3_2_2_0()); } | ||
9619 | ruleGraphPattern | ||
9620 | { after(grammarAccess.getGenerationTaskAccess().getPatternsGraphPatternParserRuleCall_3_2_2_0()); } | ||
9621 | ) | ||
9622 | ; | ||
9623 | finally { | ||
9624 | restoreStackSize(stackSize); | ||
9625 | } | ||
9626 | |||
9627 | rule__GenerationTask__ScopeAssignment_3_3_2 | ||
9628 | @init { | ||
9629 | int stackSize = keepStackSize(); | ||
9630 | } | ||
9631 | : | ||
9632 | ( | ||
9633 | { before(grammarAccess.getGenerationTaskAccess().getScopeScopeParserRuleCall_3_3_2_0()); } | ||
9634 | ruleScope | ||
9635 | { after(grammarAccess.getGenerationTaskAccess().getScopeScopeParserRuleCall_3_3_2_0()); } | ||
9636 | ) | ||
9637 | ; | ||
9638 | finally { | ||
9639 | restoreStackSize(stackSize); | ||
9640 | } | ||
9641 | |||
9642 | rule__GenerationTask__NumberSpecifiedAssignment_3_4_0 | ||
9643 | @init { | ||
9644 | int stackSize = keepStackSize(); | ||
9645 | } | ||
9646 | : | ||
9647 | ( | ||
9648 | { before(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_4_0_0()); } | ||
9649 | ( | ||
9650 | { before(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_4_0_0()); } | ||
9651 | 'number' | ||
9652 | { after(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_4_0_0()); } | ||
9653 | ) | ||
9654 | { after(grammarAccess.getGenerationTaskAccess().getNumberSpecifiedNumberKeyword_3_4_0_0()); } | ||
9655 | ) | ||
9656 | ; | ||
9657 | finally { | ||
9658 | restoreStackSize(stackSize); | ||
9659 | } | ||
9660 | |||
9661 | rule__GenerationTask__NumberAssignment_3_4_2 | ||
9662 | @init { | ||
9663 | int stackSize = keepStackSize(); | ||
9664 | } | ||
9665 | : | ||
9666 | ( | ||
9667 | { before(grammarAccess.getGenerationTaskAccess().getNumberINTTerminalRuleCall_3_4_2_0()); } | ||
9668 | RULE_INT | ||
9669 | { after(grammarAccess.getGenerationTaskAccess().getNumberINTTerminalRuleCall_3_4_2_0()); } | ||
9670 | ) | ||
9671 | ; | ||
9672 | finally { | ||
9673 | restoreStackSize(stackSize); | ||
9674 | } | ||
9675 | |||
9676 | rule__GenerationTask__RunSpecifiedAssignment_3_5_0 | ||
9677 | @init { | ||
9678 | int stackSize = keepStackSize(); | ||
9679 | } | ||
9680 | : | ||
9681 | ( | ||
9682 | { before(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_5_0_0()); } | ||
9683 | ( | ||
9684 | { before(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_5_0_0()); } | ||
9685 | 'runs' | ||
9686 | { after(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_5_0_0()); } | ||
9687 | ) | ||
9688 | { after(grammarAccess.getGenerationTaskAccess().getRunSpecifiedRunsKeyword_3_5_0_0()); } | ||
9689 | ) | ||
9690 | ; | ||
9691 | finally { | ||
9692 | restoreStackSize(stackSize); | ||
9693 | } | ||
9694 | |||
9695 | rule__GenerationTask__RunsAssignment_3_5_2 | ||
9696 | @init { | ||
9697 | int stackSize = keepStackSize(); | ||
9698 | } | ||
9699 | : | ||
9700 | ( | ||
9701 | { before(grammarAccess.getGenerationTaskAccess().getRunsINTTerminalRuleCall_3_5_2_0()); } | ||
9702 | RULE_INT | ||
9703 | { after(grammarAccess.getGenerationTaskAccess().getRunsINTTerminalRuleCall_3_5_2_0()); } | ||
9704 | ) | ||
9705 | ; | ||
9706 | finally { | ||
9707 | restoreStackSize(stackSize); | ||
9708 | } | ||
9709 | |||
9710 | rule__GenerationTask__SolverAssignment_3_6_2 | ||
9711 | @init { | ||
9712 | int stackSize = keepStackSize(); | ||
9713 | } | ||
9714 | : | ||
9715 | ( | ||
9716 | { before(grammarAccess.getGenerationTaskAccess().getSolverSolverEnumRuleCall_3_6_2_0()); } | ||
9717 | ruleSolver | ||
9718 | { after(grammarAccess.getGenerationTaskAccess().getSolverSolverEnumRuleCall_3_6_2_0()); } | ||
9719 | ) | ||
9720 | ; | ||
9721 | finally { | ||
9722 | restoreStackSize(stackSize); | ||
9723 | } | ||
9724 | |||
9725 | rule__GenerationTask__ConfigAssignment_3_7_2 | ||
9726 | @init { | ||
9727 | int stackSize = keepStackSize(); | ||
9728 | } | ||
9729 | : | ||
9730 | ( | ||
9731 | { before(grammarAccess.getGenerationTaskAccess().getConfigConfigParserRuleCall_3_7_2_0()); } | ||
9732 | ruleConfig | ||
9733 | { after(grammarAccess.getGenerationTaskAccess().getConfigConfigParserRuleCall_3_7_2_0()); } | ||
9734 | ) | ||
9735 | ; | ||
9736 | finally { | ||
9737 | restoreStackSize(stackSize); | ||
9738 | } | ||
9739 | |||
9740 | rule__GenerationTask__DebugFolderAssignment_3_8_2 | ||
9741 | @init { | ||
9742 | int stackSize = keepStackSize(); | ||
9743 | } | ||
9744 | : | ||
9745 | ( | ||
9746 | { before(grammarAccess.getGenerationTaskAccess().getDebugFolderFileParserRuleCall_3_8_2_0()); } | ||
9747 | ruleFile | ||
9748 | { after(grammarAccess.getGenerationTaskAccess().getDebugFolderFileParserRuleCall_3_8_2_0()); } | ||
9749 | ) | ||
9750 | ; | ||
9751 | finally { | ||
9752 | restoreStackSize(stackSize); | ||
9753 | } | ||
9754 | |||
9755 | rule__GenerationTask__TargetLogFileAssignment_3_9_2 | ||
9756 | @init { | ||
9757 | int stackSize = keepStackSize(); | ||
9758 | } | ||
9759 | : | ||
9760 | ( | ||
9761 | { before(grammarAccess.getGenerationTaskAccess().getTargetLogFileFileParserRuleCall_3_9_2_0()); } | ||
9762 | ruleFile | ||
9763 | { after(grammarAccess.getGenerationTaskAccess().getTargetLogFileFileParserRuleCall_3_9_2_0()); } | ||
9764 | ) | ||
9765 | ; | ||
9766 | finally { | ||
9767 | restoreStackSize(stackSize); | ||
9768 | } | ||
9769 | |||
9770 | rule__GenerationTask__TargetStatisticsFileAssignment_3_10_2 | ||
9771 | @init { | ||
9772 | int stackSize = keepStackSize(); | ||
9773 | } | ||
9774 | : | ||
9775 | ( | ||
9776 | { before(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileFileParserRuleCall_3_10_2_0()); } | ||
9777 | ruleFile | ||
9778 | { after(grammarAccess.getGenerationTaskAccess().getTargetStatisticsFileFileParserRuleCall_3_10_2_0()); } | ||
9779 | ) | ||
9780 | ; | ||
9781 | finally { | ||
9782 | restoreStackSize(stackSize); | ||
9783 | } | ||
9784 | |||
9785 | rule__GenerationTask__TagetFolderAssignment_3_11_2 | ||
9786 | @init { | ||
9787 | int stackSize = keepStackSize(); | ||
9788 | } | ||
9789 | : | ||
9790 | ( | ||
9791 | { before(grammarAccess.getGenerationTaskAccess().getTagetFolderFileParserRuleCall_3_11_2_0()); } | ||
9792 | ruleFile | ||
9793 | { after(grammarAccess.getGenerationTaskAccess().getTagetFolderFileParserRuleCall_3_11_2_0()); } | ||
9794 | ) | ||
9795 | ; | ||
9796 | finally { | ||
9797 | restoreStackSize(stackSize); | ||
9798 | } | ||
9799 | |||
1565 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | 9800 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; |
1566 | 9801 | ||
1567 | RULE_INT : ('0'..'9')+; | 9802 | RULE_INT : ('0'..'9')+; |