aboutsummaryrefslogtreecommitdiffstats
path: root/Application/hu.bme.mit.inf.dslreasoner.application.ide/src-gen/hu/bme/mit/inf/dslreasoner/application/ide/contentassist/antlr/internal/InternalApplicationConfiguration.g
diff options
context:
space:
mode:
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.g8273
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;
98finally { 98finally {
99 restoreStackSize(stackSize); 99 restoreStackSize(stackSize);
100} 100}
101 101
102// Entry rule entryRuleDeclaration 102// Entry rule entryRuleQualifiedName
103entryRuleDeclaration 103entryRuleQualifiedName
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
112ruleDeclaration 112ruleQualifiedName
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;
123finally { 123finally {
@@ -199,6 +199,131 @@ finally {
199 restoreStackSize(stackSize); 199 restoreStackSize(stackSize);
200} 200}
201 201
202// Entry rule entryRuleDeclaration
203entryRuleDeclaration
204:
205{ before(grammarAccess.getDeclarationRule()); }
206 ruleDeclaration
207{ after(grammarAccess.getDeclarationRule()); }
208 EOF
209;
210
211// Rule Declaration
212ruleDeclaration
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;
223finally {
224 restoreStackSize(stackSize);
225}
226
227// Entry rule entryRuleFileSpecification
228entryRuleFileSpecification
229:
230{ before(grammarAccess.getFileSpecificationRule()); }
231 ruleFileSpecification
232{ after(grammarAccess.getFileSpecificationRule()); }
233 EOF
234;
235
236// Rule FileSpecification
237ruleFileSpecification
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;
248finally {
249 restoreStackSize(stackSize);
250}
251
252// Entry rule entryRuleFileDeclaration
253entryRuleFileDeclaration
254:
255{ before(grammarAccess.getFileDeclarationRule()); }
256 ruleFileDeclaration
257{ after(grammarAccess.getFileDeclarationRule()); }
258 EOF
259;
260
261// Rule FileDeclaration
262ruleFileDeclaration
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;
273finally {
274 restoreStackSize(stackSize);
275}
276
277// Entry rule entryRuleFileReference
278entryRuleFileReference
279:
280{ before(grammarAccess.getFileReferenceRule()); }
281 ruleFileReference
282{ after(grammarAccess.getFileReferenceRule()); }
283 EOF
284;
285
286// Rule FileReference
287ruleFileReference
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;
298finally {
299 restoreStackSize(stackSize);
300}
301
302// Entry rule entryRuleFile
303entryRuleFile
304:
305{ before(grammarAccess.getFileRule()); }
306 ruleFile
307{ after(grammarAccess.getFileRule()); }
308 EOF
309;
310
311// Rule File
312ruleFile
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;
323finally {
324 restoreStackSize(stackSize);
325}
326
202// Entry rule entryRuleMetamodelSpecification 327// Entry rule entryRuleMetamodelSpecification
203entryRuleMetamodelSpecification 328entryRuleMetamodelSpecification
204: 329:
@@ -349,6 +474,1093 @@ finally {
349 restoreStackSize(stackSize); 474 restoreStackSize(stackSize);
350} 475}
351 476
477// Entry rule entryRuleMetamodel
478entryRuleMetamodel
479:
480{ before(grammarAccess.getMetamodelRule()); }
481 ruleMetamodel
482{ after(grammarAccess.getMetamodelRule()); }
483 EOF
484;
485
486// Rule Metamodel
487ruleMetamodel
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;
498finally {
499 restoreStackSize(stackSize);
500}
501
502// Entry rule entryRulePartialModelSpecification
503entryRulePartialModelSpecification
504:
505{ before(grammarAccess.getPartialModelSpecificationRule()); }
506 rulePartialModelSpecification
507{ after(grammarAccess.getPartialModelSpecificationRule()); }
508 EOF
509;
510
511// Rule PartialModelSpecification
512rulePartialModelSpecification
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;
523finally {
524 restoreStackSize(stackSize);
525}
526
527// Entry rule entryRulePartialModelEntry
528entryRulePartialModelEntry
529:
530{ before(grammarAccess.getPartialModelEntryRule()); }
531 rulePartialModelEntry
532{ after(grammarAccess.getPartialModelEntryRule()); }
533 EOF
534;
535
536// Rule PartialModelEntry
537rulePartialModelEntry
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;
548finally {
549 restoreStackSize(stackSize);
550}
551
552// Entry rule entryRuleModelEntry
553entryRuleModelEntry
554:
555{ before(grammarAccess.getModelEntryRule()); }
556 ruleModelEntry
557{ after(grammarAccess.getModelEntryRule()); }
558 EOF
559;
560
561// Rule ModelEntry
562ruleModelEntry
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;
573finally {
574 restoreStackSize(stackSize);
575}
576
577// Entry rule entryRuleFolderEntry
578entryRuleFolderEntry
579:
580{ before(grammarAccess.getFolderEntryRule()); }
581 ruleFolderEntry
582{ after(grammarAccess.getFolderEntryRule()); }
583 EOF
584;
585
586// Rule FolderEntry
587ruleFolderEntry
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;
598finally {
599 restoreStackSize(stackSize);
600}
601
602// Entry rule entryRulePartialModelDeclaration
603entryRulePartialModelDeclaration
604:
605{ before(grammarAccess.getPartialModelDeclarationRule()); }
606 rulePartialModelDeclaration
607{ after(grammarAccess.getPartialModelDeclarationRule()); }
608 EOF
609;
610
611// Rule PartialModelDeclaration
612rulePartialModelDeclaration
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;
623finally {
624 restoreStackSize(stackSize);
625}
626
627// Entry rule entryRulePartialModelReference
628entryRulePartialModelReference
629:
630{ before(grammarAccess.getPartialModelReferenceRule()); }
631 rulePartialModelReference
632{ after(grammarAccess.getPartialModelReferenceRule()); }
633 EOF
634;
635
636// Rule PartialModelReference
637rulePartialModelReference
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;
648finally {
649 restoreStackSize(stackSize);
650}
651
652// Entry rule entryRulePartialModel
653entryRulePartialModel
654:
655{ before(grammarAccess.getPartialModelRule()); }
656 rulePartialModel
657{ after(grammarAccess.getPartialModelRule()); }
658 EOF
659;
660
661// Rule PartialModel
662rulePartialModel
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;
673finally {
674 restoreStackSize(stackSize);
675}
676
677// Entry rule entryRulePatternSpecification
678entryRulePatternSpecification
679:
680{ before(grammarAccess.getPatternSpecificationRule()); }
681 rulePatternSpecification
682{ after(grammarAccess.getPatternSpecificationRule()); }
683 EOF
684;
685
686// Rule PatternSpecification
687rulePatternSpecification
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;
698finally {
699 restoreStackSize(stackSize);
700}
701
702// Entry rule entryRulePatternEntry
703entryRulePatternEntry
704:
705{ before(grammarAccess.getPatternEntryRule()); }
706 rulePatternEntry
707{ after(grammarAccess.getPatternEntryRule()); }
708 EOF
709;
710
711// Rule PatternEntry
712rulePatternEntry
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;
723finally {
724 restoreStackSize(stackSize);
725}
726
727// Entry rule entryRuleAllPatternEntry
728entryRuleAllPatternEntry
729:
730{ before(grammarAccess.getAllPatternEntryRule()); }
731 ruleAllPatternEntry
732{ after(grammarAccess.getAllPatternEntryRule()); }
733 EOF
734;
735
736// Rule AllPatternEntry
737ruleAllPatternEntry
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;
748finally {
749 restoreStackSize(stackSize);
750}
751
752// Entry rule entryRulePatternElement
753entryRulePatternElement
754:
755{ before(grammarAccess.getPatternElementRule()); }
756 rulePatternElement
757{ after(grammarAccess.getPatternElementRule()); }
758 EOF
759;
760
761// Rule PatternElement
762rulePatternElement
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;
773finally {
774 restoreStackSize(stackSize);
775}
776
777// Entry rule entryRuleGraphPatternDeclaration
778entryRuleGraphPatternDeclaration
779:
780{ before(grammarAccess.getGraphPatternDeclarationRule()); }
781 ruleGraphPatternDeclaration
782{ after(grammarAccess.getGraphPatternDeclarationRule()); }
783 EOF
784;
785
786// Rule GraphPatternDeclaration
787ruleGraphPatternDeclaration
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;
798finally {
799 restoreStackSize(stackSize);
800}
801
802// Entry rule entryRuleGraphPatternReference
803entryRuleGraphPatternReference
804:
805{ before(grammarAccess.getGraphPatternReferenceRule()); }
806 ruleGraphPatternReference
807{ after(grammarAccess.getGraphPatternReferenceRule()); }
808 EOF
809;
810
811// Rule GraphPatternReference
812ruleGraphPatternReference
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;
823finally {
824 restoreStackSize(stackSize);
825}
826
827// Entry rule entryRuleGraphPattern
828entryRuleGraphPattern
829:
830{ before(grammarAccess.getGraphPatternRule()); }
831 ruleGraphPattern
832{ after(grammarAccess.getGraphPatternRule()); }
833 EOF
834;
835
836// Rule GraphPattern
837ruleGraphPattern
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;
848finally {
849 restoreStackSize(stackSize);
850}
851
852// Entry rule entryRuleConfigSpecification
853entryRuleConfigSpecification
854:
855{ before(grammarAccess.getConfigSpecificationRule()); }
856 ruleConfigSpecification
857{ after(grammarAccess.getConfigSpecificationRule()); }
858 EOF
859;
860
861// Rule ConfigSpecification
862ruleConfigSpecification
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;
873finally {
874 restoreStackSize(stackSize);
875}
876
877// Entry rule entryRuleConfigDeclaration
878entryRuleConfigDeclaration
879:
880{ before(grammarAccess.getConfigDeclarationRule()); }
881 ruleConfigDeclaration
882{ after(grammarAccess.getConfigDeclarationRule()); }
883 EOF
884;
885
886// Rule ConfigDeclaration
887ruleConfigDeclaration
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;
898finally {
899 restoreStackSize(stackSize);
900}
901
902// Entry rule entryRuleConfigEntry
903entryRuleConfigEntry
904:
905{ before(grammarAccess.getConfigEntryRule()); }
906 ruleConfigEntry
907{ after(grammarAccess.getConfigEntryRule()); }
908 EOF
909;
910
911// Rule ConfigEntry
912ruleConfigEntry
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;
923finally {
924 restoreStackSize(stackSize);
925}
926
927// Entry rule entryRuleConfigReference
928entryRuleConfigReference
929:
930{ before(grammarAccess.getConfigReferenceRule()); }
931 ruleConfigReference
932{ after(grammarAccess.getConfigReferenceRule()); }
933 EOF
934;
935
936// Rule ConfigReference
937ruleConfigReference
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;
948finally {
949 restoreStackSize(stackSize);
950}
951
952// Entry rule entryRuleConfig
953entryRuleConfig
954:
955{ before(grammarAccess.getConfigRule()); }
956 ruleConfig
957{ after(grammarAccess.getConfigRule()); }
958 EOF
959;
960
961// Rule Config
962ruleConfig
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;
973finally {
974 restoreStackSize(stackSize);
975}
976
977// Entry rule entryRuleScopeSpecification
978entryRuleScopeSpecification
979:
980{ before(grammarAccess.getScopeSpecificationRule()); }
981 ruleScopeSpecification
982{ after(grammarAccess.getScopeSpecificationRule()); }
983 EOF
984;
985
986// Rule ScopeSpecification
987ruleScopeSpecification
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;
998finally {
999 restoreStackSize(stackSize);
1000}
1001
1002// Entry rule entryRuleTypeScope
1003entryRuleTypeScope
1004:
1005{ before(grammarAccess.getTypeScopeRule()); }
1006 ruleTypeScope
1007{ after(grammarAccess.getTypeScopeRule()); }
1008 EOF
1009;
1010
1011// Rule TypeScope
1012ruleTypeScope
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;
1023finally {
1024 restoreStackSize(stackSize);
1025}
1026
1027// Entry rule entryRuleClassTypeScope
1028entryRuleClassTypeScope
1029:
1030{ before(grammarAccess.getClassTypeScopeRule()); }
1031 ruleClassTypeScope
1032{ after(grammarAccess.getClassTypeScopeRule()); }
1033 EOF
1034;
1035
1036// Rule ClassTypeScope
1037ruleClassTypeScope
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;
1048finally {
1049 restoreStackSize(stackSize);
1050}
1051
1052// Entry rule entryRuleObjectTypeScope
1053entryRuleObjectTypeScope
1054:
1055{ before(grammarAccess.getObjectTypeScopeRule()); }
1056 ruleObjectTypeScope
1057{ after(grammarAccess.getObjectTypeScopeRule()); }
1058 EOF
1059;
1060
1061// Rule ObjectTypeScope
1062ruleObjectTypeScope
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;
1073finally {
1074 restoreStackSize(stackSize);
1075}
1076
1077// Entry rule entryRuleIntegerTypeScope
1078entryRuleIntegerTypeScope
1079:
1080{ before(grammarAccess.getIntegerTypeScopeRule()); }
1081 ruleIntegerTypeScope
1082{ after(grammarAccess.getIntegerTypeScopeRule()); }
1083 EOF
1084;
1085
1086// Rule IntegerTypeScope
1087ruleIntegerTypeScope
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;
1098finally {
1099 restoreStackSize(stackSize);
1100}
1101
1102// Entry rule entryRuleRealTypeScope
1103entryRuleRealTypeScope
1104:
1105{ before(grammarAccess.getRealTypeScopeRule()); }
1106 ruleRealTypeScope
1107{ after(grammarAccess.getRealTypeScopeRule()); }
1108 EOF
1109;
1110
1111// Rule RealTypeScope
1112ruleRealTypeScope
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;
1123finally {
1124 restoreStackSize(stackSize);
1125}
1126
1127// Entry rule entryRuleStringTypeScope
1128entryRuleStringTypeScope
1129:
1130{ before(grammarAccess.getStringTypeScopeRule()); }
1131 ruleStringTypeScope
1132{ after(grammarAccess.getStringTypeScopeRule()); }
1133 EOF
1134;
1135
1136// Rule StringTypeScope
1137ruleStringTypeScope
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;
1148finally {
1149 restoreStackSize(stackSize);
1150}
1151
1152// Entry rule entryRuleClassReference
1153entryRuleClassReference
1154:
1155{ before(grammarAccess.getClassReferenceRule()); }
1156 ruleClassReference
1157{ after(grammarAccess.getClassReferenceRule()); }
1158 EOF
1159;
1160
1161// Rule ClassReference
1162ruleClassReference
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;
1173finally {
1174 restoreStackSize(stackSize);
1175}
1176
1177// Entry rule entryRuleObjectReference
1178entryRuleObjectReference
1179:
1180{ before(grammarAccess.getObjectReferenceRule()); }
1181 ruleObjectReference
1182{ after(grammarAccess.getObjectReferenceRule()); }
1183 EOF
1184;
1185
1186// Rule ObjectReference
1187ruleObjectReference
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;
1198finally {
1199 restoreStackSize(stackSize);
1200}
1201
1202// Entry rule entryRuleIntegerReference
1203entryRuleIntegerReference
1204:
1205{ before(grammarAccess.getIntegerReferenceRule()); }
1206 ruleIntegerReference
1207{ after(grammarAccess.getIntegerReferenceRule()); }
1208 EOF
1209;
1210
1211// Rule IntegerReference
1212ruleIntegerReference
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;
1223finally {
1224 restoreStackSize(stackSize);
1225}
1226
1227// Entry rule entryRuleRealReference
1228entryRuleRealReference
1229:
1230{ before(grammarAccess.getRealReferenceRule()); }
1231 ruleRealReference
1232{ after(grammarAccess.getRealReferenceRule()); }
1233 EOF
1234;
1235
1236// Rule RealReference
1237ruleRealReference
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;
1248finally {
1249 restoreStackSize(stackSize);
1250}
1251
1252// Entry rule entryRuleStringReference
1253entryRuleStringReference
1254:
1255{ before(grammarAccess.getStringReferenceRule()); }
1256 ruleStringReference
1257{ after(grammarAccess.getStringReferenceRule()); }
1258 EOF
1259;
1260
1261// Rule StringReference
1262ruleStringReference
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;
1273finally {
1274 restoreStackSize(stackSize);
1275}
1276
1277// Entry rule entryRuleExactNumber
1278entryRuleExactNumber
1279:
1280{ before(grammarAccess.getExactNumberRule()); }
1281 ruleExactNumber
1282{ after(grammarAccess.getExactNumberRule()); }
1283 EOF
1284;
1285
1286// Rule ExactNumber
1287ruleExactNumber
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;
1298finally {
1299 restoreStackSize(stackSize);
1300}
1301
1302// Entry rule entryRuleIntervallNumber
1303entryRuleIntervallNumber
1304:
1305{ before(grammarAccess.getIntervallNumberRule()); }
1306 ruleIntervallNumber
1307{ after(grammarAccess.getIntervallNumberRule()); }
1308 EOF
1309;
1310
1311// Rule IntervallNumber
1312ruleIntervallNumber
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;
1323finally {
1324 restoreStackSize(stackSize);
1325}
1326
1327// Entry rule entryRuleIntEnumberation
1328entryRuleIntEnumberation
1329:
1330{ before(grammarAccess.getIntEnumberationRule()); }
1331 ruleIntEnumberation
1332{ after(grammarAccess.getIntEnumberationRule()); }
1333 EOF
1334;
1335
1336// Rule IntEnumberation
1337ruleIntEnumberation
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;
1348finally {
1349 restoreStackSize(stackSize);
1350}
1351
1352// Entry rule entryRuleRealEnumeration
1353entryRuleRealEnumeration
1354:
1355{ before(grammarAccess.getRealEnumerationRule()); }
1356 ruleRealEnumeration
1357{ after(grammarAccess.getRealEnumerationRule()); }
1358 EOF
1359;
1360
1361// Rule RealEnumeration
1362ruleRealEnumeration
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;
1373finally {
1374 restoreStackSize(stackSize);
1375}
1376
1377// Entry rule entryRuleStringEnumeration
1378entryRuleStringEnumeration
1379:
1380{ before(grammarAccess.getStringEnumerationRule()); }
1381 ruleStringEnumeration
1382{ after(grammarAccess.getStringEnumerationRule()); }
1383 EOF
1384;
1385
1386// Rule StringEnumeration
1387ruleStringEnumeration
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;
1398finally {
1399 restoreStackSize(stackSize);
1400}
1401
1402// Entry rule entryRuleScopeDeclaration
1403entryRuleScopeDeclaration
1404:
1405{ before(grammarAccess.getScopeDeclarationRule()); }
1406 ruleScopeDeclaration
1407{ after(grammarAccess.getScopeDeclarationRule()); }
1408 EOF
1409;
1410
1411// Rule ScopeDeclaration
1412ruleScopeDeclaration
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;
1423finally {
1424 restoreStackSize(stackSize);
1425}
1426
1427// Entry rule entryRuleScopeReference
1428entryRuleScopeReference
1429:
1430{ before(grammarAccess.getScopeReferenceRule()); }
1431 ruleScopeReference
1432{ after(grammarAccess.getScopeReferenceRule()); }
1433 EOF
1434;
1435
1436// Rule ScopeReference
1437ruleScopeReference
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;
1448finally {
1449 restoreStackSize(stackSize);
1450}
1451
1452// Entry rule entryRuleScope
1453entryRuleScope
1454:
1455{ before(grammarAccess.getScopeRule()); }
1456 ruleScope
1457{ after(grammarAccess.getScopeRule()); }
1458 EOF
1459;
1460
1461// Rule Scope
1462ruleScope
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;
1473finally {
1474 restoreStackSize(stackSize);
1475}
1476
1477// Entry rule entryRuleTask
1478entryRuleTask
1479:
1480{ before(grammarAccess.getTaskRule()); }
1481 ruleTask
1482{ after(grammarAccess.getTaskRule()); }
1483 EOF
1484;
1485
1486// Rule Task
1487ruleTask
1488 @init {
1489 int stackSize = keepStackSize();
1490 }
1491 :
1492 (
1493 { before(grammarAccess.getTaskAccess().getGenerationTaskParserRuleCall()); }
1494 ruleGenerationTask
1495 { after(grammarAccess.getTaskAccess().getGenerationTaskParserRuleCall()); }
1496 )
1497;
1498finally {
1499 restoreStackSize(stackSize);
1500}
1501
1502// Entry rule entryRuleGenerationTask
1503entryRuleGenerationTask
1504:
1505{ before(grammarAccess.getGenerationTaskRule()); }
1506 ruleGenerationTask
1507{ after(grammarAccess.getGenerationTaskRule()); }
1508 EOF
1509;
1510
1511// Rule GenerationTask
1512ruleGenerationTask
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;
1523finally {
1524 restoreStackSize(stackSize);
1525}
1526
1527// Rule Solver
1528ruleSolver
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;
1539finally {
1540 restoreStackSize(stackSize);
1541}
1542
1543rule__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;
1560finally {
1561 restoreStackSize(stackSize);
1562}
1563
352rule__Import__Alternatives 1564rule__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
1585rule__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;
1626finally {
1627 restoreStackSize(stackSize);
1628}
1629
1630rule__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;
1647finally {
1648 restoreStackSize(stackSize);
1649}
1650
373rule__MetamodelEntry__Alternatives 1651rule__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
1672rule__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;
1689finally {
1690 restoreStackSize(stackSize);
1691}
1692
1693rule__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;
1710finally {
1711 restoreStackSize(stackSize);
1712}
1713
1714rule__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;
1731finally {
1732 restoreStackSize(stackSize);
1733}
1734
1735rule__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;
1752finally {
1753 restoreStackSize(stackSize);
1754}
1755
1756rule__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;
1773finally {
1774 restoreStackSize(stackSize);
1775}
1776
1777rule__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;
1794finally {
1795 restoreStackSize(stackSize);
1796}
1797
1798rule__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;
1833finally {
1834 restoreStackSize(stackSize);
1835}
1836
1837rule__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;
1854finally {
1855 restoreStackSize(stackSize);
1856}
1857
1858rule__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;
1875finally {
1876 restoreStackSize(stackSize);
1877}
1878
1879rule__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;
1896finally {
1897 restoreStackSize(stackSize);
1898}
1899
1900rule__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;
1917finally {
1918 restoreStackSize(stackSize);
1919}
1920
1921rule__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;
1938finally {
1939 restoreStackSize(stackSize);
1940}
1941
1942rule__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;
1965finally {
1966 restoreStackSize(stackSize);
1967}
1968
1969rule__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;
1986finally {
1987 restoreStackSize(stackSize);
1988}
1989
1990rule__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;
2013finally {
2014 restoreStackSize(stackSize);
2015}
2016
2017rule__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;
2034finally {
2035 restoreStackSize(stackSize);
2036}
2037
2038rule__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;
2061finally {
2062 restoreStackSize(stackSize);
2063}
2064
2065rule__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;
2082finally {
2083 restoreStackSize(stackSize);
2084}
2085
2086rule__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;
2103finally {
2104 restoreStackSize(stackSize);
2105}
2106
2107rule__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;
2124finally {
2125 restoreStackSize(stackSize);
2126}
2127
2128rule__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;
2151finally {
2152 restoreStackSize(stackSize);
2153}
2154
394rule__ConfigurationScript__Group__0 2155rule__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
2209rule__QualifiedName__Group__0
2210 @init {
2211 int stackSize = keepStackSize();
2212 }
2213:
2214 rule__QualifiedName__Group__0__Impl
2215 rule__QualifiedName__Group__1
2216;
2217finally {
2218 restoreStackSize(stackSize);
2219}
2220
2221rule__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;
2232finally {
2233 restoreStackSize(stackSize);
2234}
2235
2236rule__QualifiedName__Group__1
2237 @init {
2238 int stackSize = keepStackSize();
2239 }
2240:
2241 rule__QualifiedName__Group__1__Impl
2242;
2243finally {
2244 restoreStackSize(stackSize);
2245}
2246
2247rule__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;
2258finally {
2259 restoreStackSize(stackSize);
2260}
2261
2262
2263rule__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;
2271finally {
2272 restoreStackSize(stackSize);
2273}
2274
2275rule__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;
2286finally {
2287 restoreStackSize(stackSize);
2288}
2289
2290rule__QualifiedName__Group_1__1
2291 @init {
2292 int stackSize = keepStackSize();
2293 }
2294:
2295 rule__QualifiedName__Group_1__1__Impl
2296;
2297finally {
2298 restoreStackSize(stackSize);
2299}
2300
2301rule__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;
2312finally {
2313 restoreStackSize(stackSize);
2314}
2315
2316
448rule__EPackageImport__Group__0 2317rule__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
2479rule__FileDeclaration__Group__0
2480 @init {
2481 int stackSize = keepStackSize();
2482 }
2483:
2484 rule__FileDeclaration__Group__0__Impl
2485 rule__FileDeclaration__Group__1
2486;
2487finally {
2488 restoreStackSize(stackSize);
2489}
2490
2491rule__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;
2502finally {
2503 restoreStackSize(stackSize);
2504}
2505
2506rule__FileDeclaration__Group__1
2507 @init {
2508 int stackSize = keepStackSize();
2509 }
2510:
2511 rule__FileDeclaration__Group__1__Impl
2512 rule__FileDeclaration__Group__2
2513;
2514finally {
2515 restoreStackSize(stackSize);
2516}
2517
2518rule__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;
2529finally {
2530 restoreStackSize(stackSize);
2531}
2532
2533rule__FileDeclaration__Group__2
2534 @init {
2535 int stackSize = keepStackSize();
2536 }
2537:
2538 rule__FileDeclaration__Group__2__Impl
2539 rule__FileDeclaration__Group__3
2540;
2541finally {
2542 restoreStackSize(stackSize);
2543}
2544
2545rule__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;
2556finally {
2557 restoreStackSize(stackSize);
2558}
2559
2560rule__FileDeclaration__Group__3
2561 @init {
2562 int stackSize = keepStackSize();
2563 }
2564:
2565 rule__FileDeclaration__Group__3__Impl
2566;
2567finally {
2568 restoreStackSize(stackSize);
2569}
2570
2571rule__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;
2582finally {
2583 restoreStackSize(stackSize);
2584}
2585
2586
610rule__MetamodelSpecification__Group__0 2587rule__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
3289rule__PartialModelSpecification__Group__0
3290 @init {
3291 int stackSize = keepStackSize();
3292 }
3293:
3294 rule__PartialModelSpecification__Group__0__Impl
3295 rule__PartialModelSpecification__Group__1
3296;
3297finally {
3298 restoreStackSize(stackSize);
3299}
3300
3301rule__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;
3312finally {
3313 restoreStackSize(stackSize);
3314}
3315
3316rule__PartialModelSpecification__Group__1
3317 @init {
3318 int stackSize = keepStackSize();
3319 }
3320:
3321 rule__PartialModelSpecification__Group__1__Impl
3322 rule__PartialModelSpecification__Group__2
3323;
3324finally {
3325 restoreStackSize(stackSize);
3326}
3327
3328rule__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;
3339finally {
3340 restoreStackSize(stackSize);
3341}
3342
3343rule__PartialModelSpecification__Group__2
3344 @init {
3345 int stackSize = keepStackSize();
3346 }
3347:
3348 rule__PartialModelSpecification__Group__2__Impl
3349 rule__PartialModelSpecification__Group__3
3350;
3351finally {
3352 restoreStackSize(stackSize);
3353}
3354
3355rule__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;
3366finally {
3367 restoreStackSize(stackSize);
3368}
3369
3370rule__PartialModelSpecification__Group__3
3371 @init {
3372 int stackSize = keepStackSize();
3373 }
3374:
3375 rule__PartialModelSpecification__Group__3__Impl
3376;
3377finally {
3378 restoreStackSize(stackSize);
3379}
3380
3381rule__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;
3392finally {
3393 restoreStackSize(stackSize);
3394}
3395
3396
3397rule__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;
3405finally {
3406 restoreStackSize(stackSize);
3407}
3408
3409rule__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;
3420finally {
3421 restoreStackSize(stackSize);
3422}
3423
3424rule__PartialModelSpecification__Group_2__1
3425 @init {
3426 int stackSize = keepStackSize();
3427 }
3428:
3429 rule__PartialModelSpecification__Group_2__1__Impl
3430;
3431finally {
3432 restoreStackSize(stackSize);
3433}
3434
3435rule__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;
3446finally {
3447 restoreStackSize(stackSize);
3448}
3449
3450
3451rule__FolderEntry__Group__0
3452 @init {
3453 int stackSize = keepStackSize();
3454 }
3455:
3456 rule__FolderEntry__Group__0__Impl
3457 rule__FolderEntry__Group__1
3458;
3459finally {
3460 restoreStackSize(stackSize);
3461}
3462
3463rule__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;
3474finally {
3475 restoreStackSize(stackSize);
3476}
3477
3478rule__FolderEntry__Group__1
3479 @init {
3480 int stackSize = keepStackSize();
3481 }
3482:
3483 rule__FolderEntry__Group__1__Impl
3484 rule__FolderEntry__Group__2
3485;
3486finally {
3487 restoreStackSize(stackSize);
3488}
3489
3490rule__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;
3501finally {
3502 restoreStackSize(stackSize);
3503}
3504
3505rule__FolderEntry__Group__2
3506 @init {
3507 int stackSize = keepStackSize();
3508 }
3509:
3510 rule__FolderEntry__Group__2__Impl
3511;
3512finally {
3513 restoreStackSize(stackSize);
3514}
3515
3516rule__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;
3527finally {
3528 restoreStackSize(stackSize);
3529}
3530
3531
3532rule__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;
3540finally {
3541 restoreStackSize(stackSize);
3542}
3543
3544rule__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;
3555finally {
3556 restoreStackSize(stackSize);
3557}
3558
3559rule__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;
3567finally {
3568 restoreStackSize(stackSize);
3569}
3570
3571rule__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;
3582finally {
3583 restoreStackSize(stackSize);
3584}
3585
3586rule__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;
3594finally {
3595 restoreStackSize(stackSize);
3596}
3597
3598rule__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;
3609finally {
3610 restoreStackSize(stackSize);
3611}
3612
3613rule__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;
3621finally {
3622 restoreStackSize(stackSize);
3623}
3624
3625rule__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;
3636finally {
3637 restoreStackSize(stackSize);
3638}
3639
3640rule__FolderEntry__Group_2__4
3641 @init {
3642 int stackSize = keepStackSize();
3643 }
3644:
3645 rule__FolderEntry__Group_2__4__Impl
3646;
3647finally {
3648 restoreStackSize(stackSize);
3649}
3650
3651rule__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;
3662finally {
3663 restoreStackSize(stackSize);
3664}
3665
3666
3667rule__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;
3675finally {
3676 restoreStackSize(stackSize);
3677}
3678
3679rule__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;
3690finally {
3691 restoreStackSize(stackSize);
3692}
3693
3694rule__FolderEntry__Group_2_3__1
3695 @init {
3696 int stackSize = keepStackSize();
3697 }
3698:
3699 rule__FolderEntry__Group_2_3__1__Impl
3700;
3701finally {
3702 restoreStackSize(stackSize);
3703}
3704
3705rule__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;
3716finally {
3717 restoreStackSize(stackSize);
3718}
3719
3720
3721rule__PartialModelDeclaration__Group__0
3722 @init {
3723 int stackSize = keepStackSize();
3724 }
3725:
3726 rule__PartialModelDeclaration__Group__0__Impl
3727 rule__PartialModelDeclaration__Group__1
3728;
3729finally {
3730 restoreStackSize(stackSize);
3731}
3732
3733rule__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;
3744finally {
3745 restoreStackSize(stackSize);
3746}
3747
3748rule__PartialModelDeclaration__Group__1
3749 @init {
3750 int stackSize = keepStackSize();
3751 }
3752:
3753 rule__PartialModelDeclaration__Group__1__Impl
3754 rule__PartialModelDeclaration__Group__2
3755;
3756finally {
3757 restoreStackSize(stackSize);
3758}
3759
3760rule__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;
3771finally {
3772 restoreStackSize(stackSize);
3773}
3774
3775rule__PartialModelDeclaration__Group__2
3776 @init {
3777 int stackSize = keepStackSize();
3778 }
3779:
3780 rule__PartialModelDeclaration__Group__2__Impl
3781;
3782finally {
3783 restoreStackSize(stackSize);
3784}
3785
3786rule__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;
3797finally {
3798 restoreStackSize(stackSize);
3799}
3800
3801
3802rule__PatternSpecification__Group__0
3803 @init {
3804 int stackSize = keepStackSize();
3805 }
3806:
3807 rule__PatternSpecification__Group__0__Impl
3808 rule__PatternSpecification__Group__1
3809;
3810finally {
3811 restoreStackSize(stackSize);
3812}
3813
3814rule__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;
3825finally {
3826 restoreStackSize(stackSize);
3827}
3828
3829rule__PatternSpecification__Group__1
3830 @init {
3831 int stackSize = keepStackSize();
3832 }
3833:
3834 rule__PatternSpecification__Group__1__Impl
3835 rule__PatternSpecification__Group__2
3836;
3837finally {
3838 restoreStackSize(stackSize);
3839}
3840
3841rule__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;
3852finally {
3853 restoreStackSize(stackSize);
3854}
3855
3856rule__PatternSpecification__Group__2
3857 @init {
3858 int stackSize = keepStackSize();
3859 }
3860:
3861 rule__PatternSpecification__Group__2__Impl
3862 rule__PatternSpecification__Group__3
3863;
3864finally {
3865 restoreStackSize(stackSize);
3866}
3867
3868rule__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;
3879finally {
3880 restoreStackSize(stackSize);
3881}
3882
3883rule__PatternSpecification__Group__3
3884 @init {
3885 int stackSize = keepStackSize();
3886 }
3887:
3888 rule__PatternSpecification__Group__3__Impl
3889;
3890finally {
3891 restoreStackSize(stackSize);
3892}
3893
3894rule__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;
3905finally {
3906 restoreStackSize(stackSize);
3907}
3908
3909
3910rule__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;
3918finally {
3919 restoreStackSize(stackSize);
3920}
3921
3922rule__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;
3933finally {
3934 restoreStackSize(stackSize);
3935}
3936
3937rule__PatternSpecification__Group_2__1
3938 @init {
3939 int stackSize = keepStackSize();
3940 }
3941:
3942 rule__PatternSpecification__Group_2__1__Impl
3943;
3944finally {
3945 restoreStackSize(stackSize);
3946}
3947
3948rule__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;
3959finally {
3960 restoreStackSize(stackSize);
3961}
3962
3963
3964rule__AllPatternEntry__Group__0
3965 @init {
3966 int stackSize = keepStackSize();
3967 }
3968:
3969 rule__AllPatternEntry__Group__0__Impl
3970 rule__AllPatternEntry__Group__1
3971;
3972finally {
3973 restoreStackSize(stackSize);
3974}
3975
3976rule__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;
3987finally {
3988 restoreStackSize(stackSize);
3989}
3990
3991rule__AllPatternEntry__Group__1
3992 @init {
3993 int stackSize = keepStackSize();
3994 }
3995:
3996 rule__AllPatternEntry__Group__1__Impl
3997 rule__AllPatternEntry__Group__2
3998;
3999finally {
4000 restoreStackSize(stackSize);
4001}
4002
4003rule__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;
4014finally {
4015 restoreStackSize(stackSize);
4016}
4017
4018rule__AllPatternEntry__Group__2
4019 @init {
4020 int stackSize = keepStackSize();
4021 }
4022:
4023 rule__AllPatternEntry__Group__2__Impl
4024;
4025finally {
4026 restoreStackSize(stackSize);
4027}
4028
4029rule__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;
4040finally {
4041 restoreStackSize(stackSize);
4042}
4043
4044
4045rule__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;
4053finally {
4054 restoreStackSize(stackSize);
4055}
4056
4057rule__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;
4068finally {
4069 restoreStackSize(stackSize);
4070}
4071
4072rule__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;
4080finally {
4081 restoreStackSize(stackSize);
4082}
4083
4084rule__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;
4095finally {
4096 restoreStackSize(stackSize);
4097}
4098
4099rule__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;
4107finally {
4108 restoreStackSize(stackSize);
4109}
4110
4111rule__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;
4122finally {
4123 restoreStackSize(stackSize);
4124}
4125
4126rule__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;
4134finally {
4135 restoreStackSize(stackSize);
4136}
4137
4138rule__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;
4149finally {
4150 restoreStackSize(stackSize);
4151}
4152
4153rule__AllPatternEntry__Group_2__4
4154 @init {
4155 int stackSize = keepStackSize();
4156 }
4157:
4158 rule__AllPatternEntry__Group_2__4__Impl
4159;
4160finally {
4161 restoreStackSize(stackSize);
4162}
4163
4164rule__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;
4175finally {
4176 restoreStackSize(stackSize);
4177}
4178
4179
4180rule__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;
4188finally {
4189 restoreStackSize(stackSize);
4190}
4191
4192rule__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;
4203finally {
4204 restoreStackSize(stackSize);
4205}
4206
4207rule__AllPatternEntry__Group_2_3__1
4208 @init {
4209 int stackSize = keepStackSize();
4210 }
4211:
4212 rule__AllPatternEntry__Group_2_3__1__Impl
4213;
4214finally {
4215 restoreStackSize(stackSize);
4216}
4217
4218rule__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;
4229finally {
4230 restoreStackSize(stackSize);
4231}
4232
4233
4234rule__PatternElement__Group__0
4235 @init {
4236 int stackSize = keepStackSize();
4237 }
4238:
4239 rule__PatternElement__Group__0__Impl
4240 rule__PatternElement__Group__1
4241;
4242finally {
4243 restoreStackSize(stackSize);
4244}
4245
4246rule__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;
4257finally {
4258 restoreStackSize(stackSize);
4259}
4260
4261rule__PatternElement__Group__1
4262 @init {
4263 int stackSize = keepStackSize();
4264 }
4265:
4266 rule__PatternElement__Group__1__Impl
4267;
4268finally {
4269 restoreStackSize(stackSize);
4270}
4271
4272rule__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;
4283finally {
4284 restoreStackSize(stackSize);
4285}
4286
4287
4288rule__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;
4296finally {
4297 restoreStackSize(stackSize);
4298}
4299
4300rule__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;
4311finally {
4312 restoreStackSize(stackSize);
4313}
4314
4315rule__PatternElement__Group_0__1
4316 @init {
4317 int stackSize = keepStackSize();
4318 }
4319:
4320 rule__PatternElement__Group_0__1__Impl
4321;
4322finally {
4323 restoreStackSize(stackSize);
4324}
4325
4326rule__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;
4337finally {
4338 restoreStackSize(stackSize);
4339}
4340
4341
4342rule__GraphPatternDeclaration__Group__0
4343 @init {
4344 int stackSize = keepStackSize();
4345 }
4346:
4347 rule__GraphPatternDeclaration__Group__0__Impl
4348 rule__GraphPatternDeclaration__Group__1
4349;
4350finally {
4351 restoreStackSize(stackSize);
4352}
4353
4354rule__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;
4365finally {
4366 restoreStackSize(stackSize);
4367}
4368
4369rule__GraphPatternDeclaration__Group__1
4370 @init {
4371 int stackSize = keepStackSize();
4372 }
4373:
4374 rule__GraphPatternDeclaration__Group__1__Impl
4375 rule__GraphPatternDeclaration__Group__2
4376;
4377finally {
4378 restoreStackSize(stackSize);
4379}
4380
4381rule__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;
4392finally {
4393 restoreStackSize(stackSize);
4394}
4395
4396rule__GraphPatternDeclaration__Group__2
4397 @init {
4398 int stackSize = keepStackSize();
4399 }
4400:
4401 rule__GraphPatternDeclaration__Group__2__Impl
4402;
4403finally {
4404 restoreStackSize(stackSize);
4405}
4406
4407rule__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;
4418finally {
4419 restoreStackSize(stackSize);
4420}
4421
4422
4423rule__ConfigSpecification__Group__0
4424 @init {
4425 int stackSize = keepStackSize();
4426 }
4427:
4428 rule__ConfigSpecification__Group__0__Impl
4429 rule__ConfigSpecification__Group__1
4430;
4431finally {
4432 restoreStackSize(stackSize);
4433}
4434
4435rule__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;
4446finally {
4447 restoreStackSize(stackSize);
4448}
4449
4450rule__ConfigSpecification__Group__1
4451 @init {
4452 int stackSize = keepStackSize();
4453 }
4454:
4455 rule__ConfigSpecification__Group__1__Impl
4456 rule__ConfigSpecification__Group__2
4457;
4458finally {
4459 restoreStackSize(stackSize);
4460}
4461
4462rule__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;
4473finally {
4474 restoreStackSize(stackSize);
4475}
4476
4477rule__ConfigSpecification__Group__2
4478 @init {
4479 int stackSize = keepStackSize();
4480 }
4481:
4482 rule__ConfigSpecification__Group__2__Impl
4483 rule__ConfigSpecification__Group__3
4484;
4485finally {
4486 restoreStackSize(stackSize);
4487}
4488
4489rule__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;
4500finally {
4501 restoreStackSize(stackSize);
4502}
4503
4504rule__ConfigSpecification__Group__3
4505 @init {
4506 int stackSize = keepStackSize();
4507 }
4508:
4509 rule__ConfigSpecification__Group__3__Impl
4510;
4511finally {
4512 restoreStackSize(stackSize);
4513}
4514
4515rule__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;
4526finally {
4527 restoreStackSize(stackSize);
4528}
4529
4530
4531rule__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;
4539finally {
4540 restoreStackSize(stackSize);
4541}
4542
4543rule__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;
4554finally {
4555 restoreStackSize(stackSize);
4556}
4557
4558rule__ConfigSpecification__Group_2__1
4559 @init {
4560 int stackSize = keepStackSize();
4561 }
4562:
4563 rule__ConfigSpecification__Group_2__1__Impl
4564;
4565finally {
4566 restoreStackSize(stackSize);
4567}
4568
4569rule__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;
4580finally {
4581 restoreStackSize(stackSize);
4582}
4583
4584
4585rule__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;
4593finally {
4594 restoreStackSize(stackSize);
4595}
4596
4597rule__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;
4608finally {
4609 restoreStackSize(stackSize);
4610}
4611
4612rule__ConfigSpecification__Group_2_1__1
4613 @init {
4614 int stackSize = keepStackSize();
4615 }
4616:
4617 rule__ConfigSpecification__Group_2_1__1__Impl
4618;
4619finally {
4620 restoreStackSize(stackSize);
4621}
4622
4623rule__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;
4634finally {
4635 restoreStackSize(stackSize);
4636}
4637
4638
4639rule__ConfigDeclaration__Group__0
4640 @init {
4641 int stackSize = keepStackSize();
4642 }
4643:
4644 rule__ConfigDeclaration__Group__0__Impl
4645 rule__ConfigDeclaration__Group__1
4646;
4647finally {
4648 restoreStackSize(stackSize);
4649}
4650
4651rule__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;
4662finally {
4663 restoreStackSize(stackSize);
4664}
4665
4666rule__ConfigDeclaration__Group__1
4667 @init {
4668 int stackSize = keepStackSize();
4669 }
4670:
4671 rule__ConfigDeclaration__Group__1__Impl
4672 rule__ConfigDeclaration__Group__2
4673;
4674finally {
4675 restoreStackSize(stackSize);
4676}
4677
4678rule__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;
4689finally {
4690 restoreStackSize(stackSize);
4691}
4692
4693rule__ConfigDeclaration__Group__2
4694 @init {
4695 int stackSize = keepStackSize();
4696 }
4697:
4698 rule__ConfigDeclaration__Group__2__Impl
4699;
4700finally {
4701 restoreStackSize(stackSize);
4702}
4703
4704rule__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;
4715finally {
4716 restoreStackSize(stackSize);
4717}
4718
4719
4720rule__ConfigEntry__Group__0
4721 @init {
4722 int stackSize = keepStackSize();
4723 }
4724:
4725 rule__ConfigEntry__Group__0__Impl
4726 rule__ConfigEntry__Group__1
4727;
4728finally {
4729 restoreStackSize(stackSize);
4730}
4731
4732rule__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;
4743finally {
4744 restoreStackSize(stackSize);
4745}
4746
4747rule__ConfigEntry__Group__1
4748 @init {
4749 int stackSize = keepStackSize();
4750 }
4751:
4752 rule__ConfigEntry__Group__1__Impl
4753 rule__ConfigEntry__Group__2
4754;
4755finally {
4756 restoreStackSize(stackSize);
4757}
4758
4759rule__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;
4770finally {
4771 restoreStackSize(stackSize);
4772}
4773
4774rule__ConfigEntry__Group__2
4775 @init {
4776 int stackSize = keepStackSize();
4777 }
4778:
4779 rule__ConfigEntry__Group__2__Impl
4780;
4781finally {
4782 restoreStackSize(stackSize);
4783}
4784
4785rule__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;
4796finally {
4797 restoreStackSize(stackSize);
4798}
4799
4800
4801rule__ScopeSpecification__Group__0
4802 @init {
4803 int stackSize = keepStackSize();
4804 }
4805:
4806 rule__ScopeSpecification__Group__0__Impl
4807 rule__ScopeSpecification__Group__1
4808;
4809finally {
4810 restoreStackSize(stackSize);
4811}
4812
4813rule__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;
4824finally {
4825 restoreStackSize(stackSize);
4826}
4827
4828rule__ScopeSpecification__Group__1
4829 @init {
4830 int stackSize = keepStackSize();
4831 }
4832:
4833 rule__ScopeSpecification__Group__1__Impl
4834 rule__ScopeSpecification__Group__2
4835;
4836finally {
4837 restoreStackSize(stackSize);
4838}
4839
4840rule__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;
4851finally {
4852 restoreStackSize(stackSize);
4853}
4854
4855rule__ScopeSpecification__Group__2
4856 @init {
4857 int stackSize = keepStackSize();
4858 }
4859:
4860 rule__ScopeSpecification__Group__2__Impl
4861 rule__ScopeSpecification__Group__3
4862;
4863finally {
4864 restoreStackSize(stackSize);
4865}
4866
4867rule__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;
4878finally {
4879 restoreStackSize(stackSize);
4880}
4881
4882rule__ScopeSpecification__Group__3
4883 @init {
4884 int stackSize = keepStackSize();
4885 }
4886:
4887 rule__ScopeSpecification__Group__3__Impl
4888;
4889finally {
4890 restoreStackSize(stackSize);
4891}
4892
4893rule__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;
4904finally {
4905 restoreStackSize(stackSize);
4906}
4907
4908
4909rule__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;
4917finally {
4918 restoreStackSize(stackSize);
4919}
4920
4921rule__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;
4932finally {
4933 restoreStackSize(stackSize);
4934}
4935
4936rule__ScopeSpecification__Group_2__1
4937 @init {
4938 int stackSize = keepStackSize();
4939 }
4940:
4941 rule__ScopeSpecification__Group_2__1__Impl
4942;
4943finally {
4944 restoreStackSize(stackSize);
4945}
4946
4947rule__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;
4958finally {
4959 restoreStackSize(stackSize);
4960}
4961
4962
4963rule__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;
4971finally {
4972 restoreStackSize(stackSize);
4973}
4974
4975rule__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;
4986finally {
4987 restoreStackSize(stackSize);
4988}
4989
4990rule__ScopeSpecification__Group_2_1__1
4991 @init {
4992 int stackSize = keepStackSize();
4993 }
4994:
4995 rule__ScopeSpecification__Group_2_1__1__Impl
4996;
4997finally {
4998 restoreStackSize(stackSize);
4999}
5000
5001rule__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;
5012finally {
5013 restoreStackSize(stackSize);
5014}
5015
5016
5017rule__ClassTypeScope__Group__0
5018 @init {
5019 int stackSize = keepStackSize();
5020 }
5021:
5022 rule__ClassTypeScope__Group__0__Impl
5023 rule__ClassTypeScope__Group__1
5024;
5025finally {
5026 restoreStackSize(stackSize);
5027}
5028
5029rule__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;
5040finally {
5041 restoreStackSize(stackSize);
5042}
5043
5044rule__ClassTypeScope__Group__1
5045 @init {
5046 int stackSize = keepStackSize();
5047 }
5048:
5049 rule__ClassTypeScope__Group__1__Impl
5050 rule__ClassTypeScope__Group__2
5051;
5052finally {
5053 restoreStackSize(stackSize);
5054}
5055
5056rule__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;
5067finally {
5068 restoreStackSize(stackSize);
5069}
5070
5071rule__ClassTypeScope__Group__2
5072 @init {
5073 int stackSize = keepStackSize();
5074 }
5075:
5076 rule__ClassTypeScope__Group__2__Impl
5077 rule__ClassTypeScope__Group__3
5078;
5079finally {
5080 restoreStackSize(stackSize);
5081}
5082
5083rule__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;
5094finally {
5095 restoreStackSize(stackSize);
5096}
5097
5098rule__ClassTypeScope__Group__3
5099 @init {
5100 int stackSize = keepStackSize();
5101 }
5102:
5103 rule__ClassTypeScope__Group__3__Impl
5104;
5105finally {
5106 restoreStackSize(stackSize);
5107}
5108
5109rule__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;
5120finally {
5121 restoreStackSize(stackSize);
5122}
5123
5124
5125rule__ObjectTypeScope__Group__0
5126 @init {
5127 int stackSize = keepStackSize();
5128 }
5129:
5130 rule__ObjectTypeScope__Group__0__Impl
5131 rule__ObjectTypeScope__Group__1
5132;
5133finally {
5134 restoreStackSize(stackSize);
5135}
5136
5137rule__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;
5148finally {
5149 restoreStackSize(stackSize);
5150}
5151
5152rule__ObjectTypeScope__Group__1
5153 @init {
5154 int stackSize = keepStackSize();
5155 }
5156:
5157 rule__ObjectTypeScope__Group__1__Impl
5158 rule__ObjectTypeScope__Group__2
5159;
5160finally {
5161 restoreStackSize(stackSize);
5162}
5163
5164rule__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;
5175finally {
5176 restoreStackSize(stackSize);
5177}
5178
5179rule__ObjectTypeScope__Group__2
5180 @init {
5181 int stackSize = keepStackSize();
5182 }
5183:
5184 rule__ObjectTypeScope__Group__2__Impl
5185 rule__ObjectTypeScope__Group__3
5186;
5187finally {
5188 restoreStackSize(stackSize);
5189}
5190
5191rule__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;
5202finally {
5203 restoreStackSize(stackSize);
5204}
5205
5206rule__ObjectTypeScope__Group__3
5207 @init {
5208 int stackSize = keepStackSize();
5209 }
5210:
5211 rule__ObjectTypeScope__Group__3__Impl
5212;
5213finally {
5214 restoreStackSize(stackSize);
5215}
5216
5217rule__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;
5228finally {
5229 restoreStackSize(stackSize);
5230}
5231
5232
5233rule__IntegerTypeScope__Group__0
5234 @init {
5235 int stackSize = keepStackSize();
5236 }
5237:
5238 rule__IntegerTypeScope__Group__0__Impl
5239 rule__IntegerTypeScope__Group__1
5240;
5241finally {
5242 restoreStackSize(stackSize);
5243}
5244
5245rule__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;
5256finally {
5257 restoreStackSize(stackSize);
5258}
5259
5260rule__IntegerTypeScope__Group__1
5261 @init {
5262 int stackSize = keepStackSize();
5263 }
5264:
5265 rule__IntegerTypeScope__Group__1__Impl
5266 rule__IntegerTypeScope__Group__2
5267;
5268finally {
5269 restoreStackSize(stackSize);
5270}
5271
5272rule__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;
5283finally {
5284 restoreStackSize(stackSize);
5285}
5286
5287rule__IntegerTypeScope__Group__2
5288 @init {
5289 int stackSize = keepStackSize();
5290 }
5291:
5292 rule__IntegerTypeScope__Group__2__Impl
5293 rule__IntegerTypeScope__Group__3
5294;
5295finally {
5296 restoreStackSize(stackSize);
5297}
5298
5299rule__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;
5310finally {
5311 restoreStackSize(stackSize);
5312}
5313
5314rule__IntegerTypeScope__Group__3
5315 @init {
5316 int stackSize = keepStackSize();
5317 }
5318:
5319 rule__IntegerTypeScope__Group__3__Impl
5320;
5321finally {
5322 restoreStackSize(stackSize);
5323}
5324
5325rule__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;
5336finally {
5337 restoreStackSize(stackSize);
5338}
5339
5340
5341rule__RealTypeScope__Group__0
5342 @init {
5343 int stackSize = keepStackSize();
5344 }
5345:
5346 rule__RealTypeScope__Group__0__Impl
5347 rule__RealTypeScope__Group__1
5348;
5349finally {
5350 restoreStackSize(stackSize);
5351}
5352
5353rule__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;
5364finally {
5365 restoreStackSize(stackSize);
5366}
5367
5368rule__RealTypeScope__Group__1
5369 @init {
5370 int stackSize = keepStackSize();
5371 }
5372:
5373 rule__RealTypeScope__Group__1__Impl
5374 rule__RealTypeScope__Group__2
5375;
5376finally {
5377 restoreStackSize(stackSize);
5378}
5379
5380rule__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;
5391finally {
5392 restoreStackSize(stackSize);
5393}
5394
5395rule__RealTypeScope__Group__2
5396 @init {
5397 int stackSize = keepStackSize();
5398 }
5399:
5400 rule__RealTypeScope__Group__2__Impl
5401 rule__RealTypeScope__Group__3
5402;
5403finally {
5404 restoreStackSize(stackSize);
5405}
5406
5407rule__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;
5418finally {
5419 restoreStackSize(stackSize);
5420}
5421
5422rule__RealTypeScope__Group__3
5423 @init {
5424 int stackSize = keepStackSize();
5425 }
5426:
5427 rule__RealTypeScope__Group__3__Impl
5428;
5429finally {
5430 restoreStackSize(stackSize);
5431}
5432
5433rule__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;
5444finally {
5445 restoreStackSize(stackSize);
5446}
5447
5448
5449rule__StringTypeScope__Group__0
5450 @init {
5451 int stackSize = keepStackSize();
5452 }
5453:
5454 rule__StringTypeScope__Group__0__Impl
5455 rule__StringTypeScope__Group__1
5456;
5457finally {
5458 restoreStackSize(stackSize);
5459}
5460
5461rule__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;
5472finally {
5473 restoreStackSize(stackSize);
5474}
5475
5476rule__StringTypeScope__Group__1
5477 @init {
5478 int stackSize = keepStackSize();
5479 }
5480:
5481 rule__StringTypeScope__Group__1__Impl
5482 rule__StringTypeScope__Group__2
5483;
5484finally {
5485 restoreStackSize(stackSize);
5486}
5487
5488rule__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;
5499finally {
5500 restoreStackSize(stackSize);
5501}
5502
5503rule__StringTypeScope__Group__2
5504 @init {
5505 int stackSize = keepStackSize();
5506 }
5507:
5508 rule__StringTypeScope__Group__2__Impl
5509 rule__StringTypeScope__Group__3
5510;
5511finally {
5512 restoreStackSize(stackSize);
5513}
5514
5515rule__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;
5526finally {
5527 restoreStackSize(stackSize);
5528}
5529
5530rule__StringTypeScope__Group__3
5531 @init {
5532 int stackSize = keepStackSize();
5533 }
5534:
5535 rule__StringTypeScope__Group__3__Impl
5536;
5537finally {
5538 restoreStackSize(stackSize);
5539}
5540
5541rule__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;
5552finally {
5553 restoreStackSize(stackSize);
5554}
5555
5556
5557rule__ClassReference__Group__0
5558 @init {
5559 int stackSize = keepStackSize();
5560 }
5561:
5562 rule__ClassReference__Group__0__Impl
5563 rule__ClassReference__Group__1
5564;
5565finally {
5566 restoreStackSize(stackSize);
5567}
5568
5569rule__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;
5580finally {
5581 restoreStackSize(stackSize);
5582}
5583
5584rule__ClassReference__Group__1
5585 @init {
5586 int stackSize = keepStackSize();
5587 }
5588:
5589 rule__ClassReference__Group__1__Impl
5590 rule__ClassReference__Group__2
5591;
5592finally {
5593 restoreStackSize(stackSize);
5594}
5595
5596rule__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;
5607finally {
5608 restoreStackSize(stackSize);
5609}
5610
5611rule__ClassReference__Group__2
5612 @init {
5613 int stackSize = keepStackSize();
5614 }
5615:
5616 rule__ClassReference__Group__2__Impl
5617;
5618finally {
5619 restoreStackSize(stackSize);
5620}
5621
5622rule__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;
5633finally {
5634 restoreStackSize(stackSize);
5635}
5636
5637
5638rule__ObjectReference__Group__0
5639 @init {
5640 int stackSize = keepStackSize();
5641 }
5642:
5643 rule__ObjectReference__Group__0__Impl
5644 rule__ObjectReference__Group__1
5645;
5646finally {
5647 restoreStackSize(stackSize);
5648}
5649
5650rule__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;
5661finally {
5662 restoreStackSize(stackSize);
5663}
5664
5665rule__ObjectReference__Group__1
5666 @init {
5667 int stackSize = keepStackSize();
5668 }
5669:
5670 rule__ObjectReference__Group__1__Impl
5671;
5672finally {
5673 restoreStackSize(stackSize);
5674}
5675
5676rule__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;
5687finally {
5688 restoreStackSize(stackSize);
5689}
5690
5691
5692rule__IntegerReference__Group__0
5693 @init {
5694 int stackSize = keepStackSize();
5695 }
5696:
5697 rule__IntegerReference__Group__0__Impl
5698 rule__IntegerReference__Group__1
5699;
5700finally {
5701 restoreStackSize(stackSize);
5702}
5703
5704rule__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;
5715finally {
5716 restoreStackSize(stackSize);
5717}
5718
5719rule__IntegerReference__Group__1
5720 @init {
5721 int stackSize = keepStackSize();
5722 }
5723:
5724 rule__IntegerReference__Group__1__Impl
5725;
5726finally {
5727 restoreStackSize(stackSize);
5728}
5729
5730rule__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;
5741finally {
5742 restoreStackSize(stackSize);
5743}
5744
5745
5746rule__RealReference__Group__0
5747 @init {
5748 int stackSize = keepStackSize();
5749 }
5750:
5751 rule__RealReference__Group__0__Impl
5752 rule__RealReference__Group__1
5753;
5754finally {
5755 restoreStackSize(stackSize);
5756}
5757
5758rule__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;
5769finally {
5770 restoreStackSize(stackSize);
5771}
5772
5773rule__RealReference__Group__1
5774 @init {
5775 int stackSize = keepStackSize();
5776 }
5777:
5778 rule__RealReference__Group__1__Impl
5779;
5780finally {
5781 restoreStackSize(stackSize);
5782}
5783
5784rule__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;
5795finally {
5796 restoreStackSize(stackSize);
5797}
5798
5799
5800rule__StringReference__Group__0
5801 @init {
5802 int stackSize = keepStackSize();
5803 }
5804:
5805 rule__StringReference__Group__0__Impl
5806 rule__StringReference__Group__1
5807;
5808finally {
5809 restoreStackSize(stackSize);
5810}
5811
5812rule__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;
5823finally {
5824 restoreStackSize(stackSize);
5825}
5826
5827rule__StringReference__Group__1
5828 @init {
5829 int stackSize = keepStackSize();
5830 }
5831:
5832 rule__StringReference__Group__1__Impl
5833;
5834finally {
5835 restoreStackSize(stackSize);
5836}
5837
5838rule__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;
5849finally {
5850 restoreStackSize(stackSize);
5851}
5852
5853
5854rule__IntervallNumber__Group__0
5855 @init {
5856 int stackSize = keepStackSize();
5857 }
5858:
5859 rule__IntervallNumber__Group__0__Impl
5860 rule__IntervallNumber__Group__1
5861;
5862finally {
5863 restoreStackSize(stackSize);
5864}
5865
5866rule__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;
5877finally {
5878 restoreStackSize(stackSize);
5879}
5880
5881rule__IntervallNumber__Group__1
5882 @init {
5883 int stackSize = keepStackSize();
5884 }
5885:
5886 rule__IntervallNumber__Group__1__Impl
5887 rule__IntervallNumber__Group__2
5888;
5889finally {
5890 restoreStackSize(stackSize);
5891}
5892
5893rule__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;
5904finally {
5905 restoreStackSize(stackSize);
5906}
5907
5908rule__IntervallNumber__Group__2
5909 @init {
5910 int stackSize = keepStackSize();
5911 }
5912:
5913 rule__IntervallNumber__Group__2__Impl
5914;
5915finally {
5916 restoreStackSize(stackSize);
5917}
5918
5919rule__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;
5930finally {
5931 restoreStackSize(stackSize);
5932}
5933
5934
5935rule__IntEnumberation__Group__0
5936 @init {
5937 int stackSize = keepStackSize();
5938 }
5939:
5940 rule__IntEnumberation__Group__0__Impl
5941 rule__IntEnumberation__Group__1
5942;
5943finally {
5944 restoreStackSize(stackSize);
5945}
5946
5947rule__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;
5958finally {
5959 restoreStackSize(stackSize);
5960}
5961
5962rule__IntEnumberation__Group__1
5963 @init {
5964 int stackSize = keepStackSize();
5965 }
5966:
5967 rule__IntEnumberation__Group__1__Impl
5968 rule__IntEnumberation__Group__2
5969;
5970finally {
5971 restoreStackSize(stackSize);
5972}
5973
5974rule__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;
5985finally {
5986 restoreStackSize(stackSize);
5987}
5988
5989rule__IntEnumberation__Group__2
5990 @init {
5991 int stackSize = keepStackSize();
5992 }
5993:
5994 rule__IntEnumberation__Group__2__Impl
5995 rule__IntEnumberation__Group__3
5996;
5997finally {
5998 restoreStackSize(stackSize);
5999}
6000
6001rule__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;
6012finally {
6013 restoreStackSize(stackSize);
6014}
6015
6016rule__IntEnumberation__Group__3
6017 @init {
6018 int stackSize = keepStackSize();
6019 }
6020:
6021 rule__IntEnumberation__Group__3__Impl
6022;
6023finally {
6024 restoreStackSize(stackSize);
6025}
6026
6027rule__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;
6038finally {
6039 restoreStackSize(stackSize);
6040}
6041
6042
6043rule__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;
6051finally {
6052 restoreStackSize(stackSize);
6053}
6054
6055rule__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;
6066finally {
6067 restoreStackSize(stackSize);
6068}
6069
6070rule__IntEnumberation__Group_2__1
6071 @init {
6072 int stackSize = keepStackSize();
6073 }
6074:
6075 rule__IntEnumberation__Group_2__1__Impl
6076;
6077finally {
6078 restoreStackSize(stackSize);
6079}
6080
6081rule__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;
6092finally {
6093 restoreStackSize(stackSize);
6094}
6095
6096
6097rule__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;
6105finally {
6106 restoreStackSize(stackSize);
6107}
6108
6109rule__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;
6120finally {
6121 restoreStackSize(stackSize);
6122}
6123
6124rule__IntEnumberation__Group_2_1__1
6125 @init {
6126 int stackSize = keepStackSize();
6127 }
6128:
6129 rule__IntEnumberation__Group_2_1__1__Impl
6130;
6131finally {
6132 restoreStackSize(stackSize);
6133}
6134
6135rule__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;
6146finally {
6147 restoreStackSize(stackSize);
6148}
6149
6150
6151rule__RealEnumeration__Group__0
6152 @init {
6153 int stackSize = keepStackSize();
6154 }
6155:
6156 rule__RealEnumeration__Group__0__Impl
6157 rule__RealEnumeration__Group__1
6158;
6159finally {
6160 restoreStackSize(stackSize);
6161}
6162
6163rule__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;
6174finally {
6175 restoreStackSize(stackSize);
6176}
6177
6178rule__RealEnumeration__Group__1
6179 @init {
6180 int stackSize = keepStackSize();
6181 }
6182:
6183 rule__RealEnumeration__Group__1__Impl
6184 rule__RealEnumeration__Group__2
6185;
6186finally {
6187 restoreStackSize(stackSize);
6188}
6189
6190rule__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;
6201finally {
6202 restoreStackSize(stackSize);
6203}
6204
6205rule__RealEnumeration__Group__2
6206 @init {
6207 int stackSize = keepStackSize();
6208 }
6209:
6210 rule__RealEnumeration__Group__2__Impl
6211 rule__RealEnumeration__Group__3
6212;
6213finally {
6214 restoreStackSize(stackSize);
6215}
6216
6217rule__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;
6228finally {
6229 restoreStackSize(stackSize);
6230}
6231
6232rule__RealEnumeration__Group__3
6233 @init {
6234 int stackSize = keepStackSize();
6235 }
6236:
6237 rule__RealEnumeration__Group__3__Impl
6238;
6239finally {
6240 restoreStackSize(stackSize);
6241}
6242
6243rule__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;
6254finally {
6255 restoreStackSize(stackSize);
6256}
6257
6258
6259rule__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;
6267finally {
6268 restoreStackSize(stackSize);
6269}
6270
6271rule__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;
6282finally {
6283 restoreStackSize(stackSize);
6284}
6285
6286rule__RealEnumeration__Group_2__1
6287 @init {
6288 int stackSize = keepStackSize();
6289 }
6290:
6291 rule__RealEnumeration__Group_2__1__Impl
6292;
6293finally {
6294 restoreStackSize(stackSize);
6295}
6296
6297rule__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;
6308finally {
6309 restoreStackSize(stackSize);
6310}
6311
6312
6313rule__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;
6321finally {
6322 restoreStackSize(stackSize);
6323}
6324
6325rule__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;
6336finally {
6337 restoreStackSize(stackSize);
6338}
6339
6340rule__RealEnumeration__Group_2_1__1
6341 @init {
6342 int stackSize = keepStackSize();
6343 }
6344:
6345 rule__RealEnumeration__Group_2_1__1__Impl
6346;
6347finally {
6348 restoreStackSize(stackSize);
6349}
6350
6351rule__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;
6362finally {
6363 restoreStackSize(stackSize);
6364}
6365
6366
6367rule__StringEnumeration__Group__0
6368 @init {
6369 int stackSize = keepStackSize();
6370 }
6371:
6372 rule__StringEnumeration__Group__0__Impl
6373 rule__StringEnumeration__Group__1
6374;
6375finally {
6376 restoreStackSize(stackSize);
6377}
6378
6379rule__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;
6390finally {
6391 restoreStackSize(stackSize);
6392}
6393
6394rule__StringEnumeration__Group__1
6395 @init {
6396 int stackSize = keepStackSize();
6397 }
6398:
6399 rule__StringEnumeration__Group__1__Impl
6400 rule__StringEnumeration__Group__2
6401;
6402finally {
6403 restoreStackSize(stackSize);
6404}
6405
6406rule__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;
6417finally {
6418 restoreStackSize(stackSize);
6419}
6420
6421rule__StringEnumeration__Group__2
6422 @init {
6423 int stackSize = keepStackSize();
6424 }
6425:
6426 rule__StringEnumeration__Group__2__Impl
6427 rule__StringEnumeration__Group__3
6428;
6429finally {
6430 restoreStackSize(stackSize);
6431}
6432
6433rule__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;
6444finally {
6445 restoreStackSize(stackSize);
6446}
6447
6448rule__StringEnumeration__Group__3
6449 @init {
6450 int stackSize = keepStackSize();
6451 }
6452:
6453 rule__StringEnumeration__Group__3__Impl
6454;
6455finally {
6456 restoreStackSize(stackSize);
6457}
6458
6459rule__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;
6470finally {
6471 restoreStackSize(stackSize);
6472}
6473
6474
6475rule__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;
6483finally {
6484 restoreStackSize(stackSize);
6485}
6486
6487rule__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;
6498finally {
6499 restoreStackSize(stackSize);
6500}
6501
6502rule__StringEnumeration__Group_2__1
6503 @init {
6504 int stackSize = keepStackSize();
6505 }
6506:
6507 rule__StringEnumeration__Group_2__1__Impl
6508;
6509finally {
6510 restoreStackSize(stackSize);
6511}
6512
6513rule__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;
6524finally {
6525 restoreStackSize(stackSize);
6526}
6527
6528
6529rule__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;
6537finally {
6538 restoreStackSize(stackSize);
6539}
6540
6541rule__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;
6552finally {
6553 restoreStackSize(stackSize);
6554}
6555
6556rule__StringEnumeration__Group_2_1__1
6557 @init {
6558 int stackSize = keepStackSize();
6559 }
6560:
6561 rule__StringEnumeration__Group_2_1__1__Impl
6562;
6563finally {
6564 restoreStackSize(stackSize);
6565}
6566
6567rule__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;
6578finally {
6579 restoreStackSize(stackSize);
6580}
6581
6582
6583rule__ScopeDeclaration__Group__0
6584 @init {
6585 int stackSize = keepStackSize();
6586 }
6587:
6588 rule__ScopeDeclaration__Group__0__Impl
6589 rule__ScopeDeclaration__Group__1
6590;
6591finally {
6592 restoreStackSize(stackSize);
6593}
6594
6595rule__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;
6606finally {
6607 restoreStackSize(stackSize);
6608}
6609
6610rule__ScopeDeclaration__Group__1
6611 @init {
6612 int stackSize = keepStackSize();
6613 }
6614:
6615 rule__ScopeDeclaration__Group__1__Impl
6616 rule__ScopeDeclaration__Group__2
6617;
6618finally {
6619 restoreStackSize(stackSize);
6620}
6621
6622rule__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;
6633finally {
6634 restoreStackSize(stackSize);
6635}
6636
6637rule__ScopeDeclaration__Group__2
6638 @init {
6639 int stackSize = keepStackSize();
6640 }
6641:
6642 rule__ScopeDeclaration__Group__2__Impl
6643;
6644finally {
6645 restoreStackSize(stackSize);
6646}
6647
6648rule__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;
6659finally {
6660 restoreStackSize(stackSize);
6661}
6662
6663
6664rule__GenerationTask__Group__0
6665 @init {
6666 int stackSize = keepStackSize();
6667 }
6668:
6669 rule__GenerationTask__Group__0__Impl
6670 rule__GenerationTask__Group__1
6671;
6672finally {
6673 restoreStackSize(stackSize);
6674}
6675
6676rule__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;
6687finally {
6688 restoreStackSize(stackSize);
6689}
6690
6691rule__GenerationTask__Group__1
6692 @init {
6693 int stackSize = keepStackSize();
6694 }
6695:
6696 rule__GenerationTask__Group__1__Impl
6697 rule__GenerationTask__Group__2
6698;
6699finally {
6700 restoreStackSize(stackSize);
6701}
6702
6703rule__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;
6714finally {
6715 restoreStackSize(stackSize);
6716}
6717
6718rule__GenerationTask__Group__2
6719 @init {
6720 int stackSize = keepStackSize();
6721 }
6722:
6723 rule__GenerationTask__Group__2__Impl
6724 rule__GenerationTask__Group__3
6725;
6726finally {
6727 restoreStackSize(stackSize);
6728}
6729
6730rule__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;
6741finally {
6742 restoreStackSize(stackSize);
6743}
6744
6745rule__GenerationTask__Group__3
6746 @init {
6747 int stackSize = keepStackSize();
6748 }
6749:
6750 rule__GenerationTask__Group__3__Impl
6751 rule__GenerationTask__Group__4
6752;
6753finally {
6754 restoreStackSize(stackSize);
6755}
6756
6757rule__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;
6768finally {
6769 restoreStackSize(stackSize);
6770}
6771
6772rule__GenerationTask__Group__4
6773 @init {
6774 int stackSize = keepStackSize();
6775 }
6776:
6777 rule__GenerationTask__Group__4__Impl
6778;
6779finally {
6780 restoreStackSize(stackSize);
6781}
6782
6783rule__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;
6794finally {
6795 restoreStackSize(stackSize);
6796}
6797
6798
6799rule__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;
6807finally {
6808 restoreStackSize(stackSize);
6809}
6810
6811rule__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;
6822finally {
6823 restoreStackSize(stackSize);
6824}
6825
6826rule__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;
6834finally {
6835 restoreStackSize(stackSize);
6836}
6837
6838rule__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;
6849finally {
6850 restoreStackSize(stackSize);
6851}
6852
6853rule__GenerationTask__Group_3_0__2
6854 @init {
6855 int stackSize = keepStackSize();
6856 }
6857:
6858 rule__GenerationTask__Group_3_0__2__Impl
6859;
6860finally {
6861 restoreStackSize(stackSize);
6862}
6863
6864rule__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;
6875finally {
6876 restoreStackSize(stackSize);
6877}
6878
6879
6880rule__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;
6888finally {
6889 restoreStackSize(stackSize);
6890}
6891
6892rule__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;
6903finally {
6904 restoreStackSize(stackSize);
6905}
6906
6907rule__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;
6915finally {
6916 restoreStackSize(stackSize);
6917}
6918
6919rule__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;
6930finally {
6931 restoreStackSize(stackSize);
6932}
6933
6934rule__GenerationTask__Group_3_1__2
6935 @init {
6936 int stackSize = keepStackSize();
6937 }
6938:
6939 rule__GenerationTask__Group_3_1__2__Impl
6940;
6941finally {
6942 restoreStackSize(stackSize);
6943}
6944
6945rule__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;
6956finally {
6957 restoreStackSize(stackSize);
6958}
6959
6960
6961rule__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;
6969finally {
6970 restoreStackSize(stackSize);
6971}
6972
6973rule__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;
6984finally {
6985 restoreStackSize(stackSize);
6986}
6987
6988rule__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;
6996finally {
6997 restoreStackSize(stackSize);
6998}
6999
7000rule__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;
7011finally {
7012 restoreStackSize(stackSize);
7013}
7014
7015rule__GenerationTask__Group_3_2__2
7016 @init {
7017 int stackSize = keepStackSize();
7018 }
7019:
7020 rule__GenerationTask__Group_3_2__2__Impl
7021;
7022finally {
7023 restoreStackSize(stackSize);
7024}
7025
7026rule__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;
7037finally {
7038 restoreStackSize(stackSize);
7039}
7040
7041
7042rule__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;
7050finally {
7051 restoreStackSize(stackSize);
7052}
7053
7054rule__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;
7065finally {
7066 restoreStackSize(stackSize);
7067}
7068
7069rule__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;
7077finally {
7078 restoreStackSize(stackSize);
7079}
7080
7081rule__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;
7092finally {
7093 restoreStackSize(stackSize);
7094}
7095
7096rule__GenerationTask__Group_3_3__2
7097 @init {
7098 int stackSize = keepStackSize();
7099 }
7100:
7101 rule__GenerationTask__Group_3_3__2__Impl
7102;
7103finally {
7104 restoreStackSize(stackSize);
7105}
7106
7107rule__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;
7118finally {
7119 restoreStackSize(stackSize);
7120}
7121
7122
7123rule__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;
7131finally {
7132 restoreStackSize(stackSize);
7133}
7134
7135rule__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;
7146finally {
7147 restoreStackSize(stackSize);
7148}
7149
7150rule__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;
7158finally {
7159 restoreStackSize(stackSize);
7160}
7161
7162rule__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;
7173finally {
7174 restoreStackSize(stackSize);
7175}
7176
7177rule__GenerationTask__Group_3_4__2
7178 @init {
7179 int stackSize = keepStackSize();
7180 }
7181:
7182 rule__GenerationTask__Group_3_4__2__Impl
7183;
7184finally {
7185 restoreStackSize(stackSize);
7186}
7187
7188rule__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;
7199finally {
7200 restoreStackSize(stackSize);
7201}
7202
7203
7204rule__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;
7212finally {
7213 restoreStackSize(stackSize);
7214}
7215
7216rule__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;
7227finally {
7228 restoreStackSize(stackSize);
7229}
7230
7231rule__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;
7239finally {
7240 restoreStackSize(stackSize);
7241}
7242
7243rule__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;
7254finally {
7255 restoreStackSize(stackSize);
7256}
7257
7258rule__GenerationTask__Group_3_5__2
7259 @init {
7260 int stackSize = keepStackSize();
7261 }
7262:
7263 rule__GenerationTask__Group_3_5__2__Impl
7264;
7265finally {
7266 restoreStackSize(stackSize);
7267}
7268
7269rule__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;
7280finally {
7281 restoreStackSize(stackSize);
7282}
7283
7284
7285rule__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;
7293finally {
7294 restoreStackSize(stackSize);
7295}
7296
7297rule__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;
7308finally {
7309 restoreStackSize(stackSize);
7310}
7311
7312rule__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;
7320finally {
7321 restoreStackSize(stackSize);
7322}
7323
7324rule__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;
7335finally {
7336 restoreStackSize(stackSize);
7337}
7338
7339rule__GenerationTask__Group_3_6__2
7340 @init {
7341 int stackSize = keepStackSize();
7342 }
7343:
7344 rule__GenerationTask__Group_3_6__2__Impl
7345;
7346finally {
7347 restoreStackSize(stackSize);
7348}
7349
7350rule__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;
7361finally {
7362 restoreStackSize(stackSize);
7363}
7364
7365
7366rule__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;
7374finally {
7375 restoreStackSize(stackSize);
7376}
7377
7378rule__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;
7389finally {
7390 restoreStackSize(stackSize);
7391}
7392
7393rule__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;
7401finally {
7402 restoreStackSize(stackSize);
7403}
7404
7405rule__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;
7416finally {
7417 restoreStackSize(stackSize);
7418}
7419
7420rule__GenerationTask__Group_3_7__2
7421 @init {
7422 int stackSize = keepStackSize();
7423 }
7424:
7425 rule__GenerationTask__Group_3_7__2__Impl
7426;
7427finally {
7428 restoreStackSize(stackSize);
7429}
7430
7431rule__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;
7442finally {
7443 restoreStackSize(stackSize);
7444}
7445
7446
7447rule__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;
7455finally {
7456 restoreStackSize(stackSize);
7457}
7458
7459rule__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;
7470finally {
7471 restoreStackSize(stackSize);
7472}
7473
7474rule__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;
7482finally {
7483 restoreStackSize(stackSize);
7484}
7485
7486rule__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;
7497finally {
7498 restoreStackSize(stackSize);
7499}
7500
7501rule__GenerationTask__Group_3_8__2
7502 @init {
7503 int stackSize = keepStackSize();
7504 }
7505:
7506 rule__GenerationTask__Group_3_8__2__Impl
7507;
7508finally {
7509 restoreStackSize(stackSize);
7510}
7511
7512rule__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;
7523finally {
7524 restoreStackSize(stackSize);
7525}
7526
7527
7528rule__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;
7536finally {
7537 restoreStackSize(stackSize);
7538}
7539
7540rule__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;
7551finally {
7552 restoreStackSize(stackSize);
7553}
7554
7555rule__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;
7563finally {
7564 restoreStackSize(stackSize);
7565}
7566
7567rule__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;
7578finally {
7579 restoreStackSize(stackSize);
7580}
7581
7582rule__GenerationTask__Group_3_9__2
7583 @init {
7584 int stackSize = keepStackSize();
7585 }
7586:
7587 rule__GenerationTask__Group_3_9__2__Impl
7588;
7589finally {
7590 restoreStackSize(stackSize);
7591}
7592
7593rule__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;
7604finally {
7605 restoreStackSize(stackSize);
7606}
7607
7608
7609rule__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;
7617finally {
7618 restoreStackSize(stackSize);
7619}
7620
7621rule__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;
7632finally {
7633 restoreStackSize(stackSize);
7634}
7635
7636rule__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;
7644finally {
7645 restoreStackSize(stackSize);
7646}
7647
7648rule__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;
7659finally {
7660 restoreStackSize(stackSize);
7661}
7662
7663rule__GenerationTask__Group_3_10__2
7664 @init {
7665 int stackSize = keepStackSize();
7666 }
7667:
7668 rule__GenerationTask__Group_3_10__2__Impl
7669;
7670finally {
7671 restoreStackSize(stackSize);
7672}
7673
7674rule__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;
7685finally {
7686 restoreStackSize(stackSize);
7687}
7688
7689
7690rule__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;
7698finally {
7699 restoreStackSize(stackSize);
7700}
7701
7702rule__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;
7713finally {
7714 restoreStackSize(stackSize);
7715}
7716
7717rule__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;
7725finally {
7726 restoreStackSize(stackSize);
7727}
7728
7729rule__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;
7740finally {
7741 restoreStackSize(stackSize);
7742}
7743
7744rule__GenerationTask__Group_3_11__2
7745 @init {
7746 int stackSize = keepStackSize();
7747 }
7748:
7749 rule__GenerationTask__Group_3_11__2__Impl
7750;
7751finally {
7752 restoreStackSize(stackSize);
7753}
7754
7755rule__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;
7766finally {
7767 restoreStackSize(stackSize);
7768}
7769
7770
7771rule__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;
7780finally {
7781 getUnorderedGroupHelper().leave(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3());
7782 restoreStackSize(stackSize);
7783}
7784
7785rule__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;
7974finally {
7975 if (selected)
7976 getUnorderedGroupHelper().returnFromSelection(grammarAccess.getGenerationTaskAccess().getUnorderedGroup_3());
7977 restoreStackSize(stackSize);
7978}
7979
7980rule__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;
7988finally {
7989 restoreStackSize(stackSize);
7990}
7991
7992rule__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;
8000finally {
8001 restoreStackSize(stackSize);
8002}
8003
8004rule__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;
8012finally {
8013 restoreStackSize(stackSize);
8014}
8015
8016rule__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;
8024finally {
8025 restoreStackSize(stackSize);
8026}
8027
8028rule__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;
8036finally {
8037 restoreStackSize(stackSize);
8038}
8039
8040rule__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;
8048finally {
8049 restoreStackSize(stackSize);
8050}
8051
8052rule__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;
8060finally {
8061 restoreStackSize(stackSize);
8062}
8063
8064rule__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;
8072finally {
8073 restoreStackSize(stackSize);
8074}
8075
8076rule__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;
8084finally {
8085 restoreStackSize(stackSize);
8086}
8087
8088rule__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;
8096finally {
8097 restoreStackSize(stackSize);
8098}
8099
8100rule__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;
8108finally {
8109 restoreStackSize(stackSize);
8110}
8111
8112rule__GenerationTask__UnorderedGroup_3__11
8113 @init {
8114 int stackSize = keepStackSize();
8115 }
8116:
8117 rule__GenerationTask__UnorderedGroup_3__Impl
8118;
8119finally {
8120 restoreStackSize(stackSize);
8121}
8122
8123
1312rule__ConfigurationScript__ImportsAssignment_0 8124rule__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
8192rule__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;
8203finally {
8204 restoreStackSize(stackSize);
8205}
8206
8207rule__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;
8218finally {
8219 restoreStackSize(stackSize);
8220}
8221
8222rule__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;
8233finally {
8234 restoreStackSize(stackSize);
8235}
8236
8237rule__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;
8252finally {
8253 restoreStackSize(stackSize);
8254}
8255
1380rule__MetamodelSpecification__EntriesAssignment_1 8256rule__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
8441rule__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;
8452finally {
8453 restoreStackSize(stackSize);
8454}
8455
8456rule__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;
8467finally {
8468 restoreStackSize(stackSize);
8469}
8470
8471rule__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;
8482finally {
8483 restoreStackSize(stackSize);
8484}
8485
8486rule__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;
8497finally {
8498 restoreStackSize(stackSize);
8499}
8500
8501rule__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;
8512finally {
8513 restoreStackSize(stackSize);
8514}
8515
8516rule__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;
8527finally {
8528 restoreStackSize(stackSize);
8529}
8530
8531rule__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;
8542finally {
8543 restoreStackSize(stackSize);
8544}
8545
8546rule__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;
8557finally {
8558 restoreStackSize(stackSize);
8559}
8560
8561rule__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;
8576finally {
8577 restoreStackSize(stackSize);
8578}
8579
8580rule__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;
8591finally {
8592 restoreStackSize(stackSize);
8593}
8594
8595rule__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;
8606finally {
8607 restoreStackSize(stackSize);
8608}
8609
8610rule__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;
8625finally {
8626 restoreStackSize(stackSize);
8627}
8628
8629rule__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;
8640finally {
8641 restoreStackSize(stackSize);
8642}
8643
8644rule__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;
8655finally {
8656 restoreStackSize(stackSize);
8657}
8658
8659rule__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;
8674finally {
8675 restoreStackSize(stackSize);
8676}
8677
8678rule__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;
8693finally {
8694 restoreStackSize(stackSize);
8695}
8696
8697rule__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;
8708finally {
8709 restoreStackSize(stackSize);
8710}
8711
8712rule__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;
8723finally {
8724 restoreStackSize(stackSize);
8725}
8726
8727rule__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;
8742finally {
8743 restoreStackSize(stackSize);
8744}
8745
8746rule__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;
8757finally {
8758 restoreStackSize(stackSize);
8759}
8760
8761rule__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;
8772finally {
8773 restoreStackSize(stackSize);
8774}
8775
8776rule__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;
8787finally {
8788 restoreStackSize(stackSize);
8789}
8790
8791rule__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;
8802finally {
8803 restoreStackSize(stackSize);
8804}
8805
8806rule__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;
8817finally {
8818 restoreStackSize(stackSize);
8819}
8820
8821rule__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;
8832finally {
8833 restoreStackSize(stackSize);
8834}
8835
8836rule__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;
8851finally {
8852 restoreStackSize(stackSize);
8853}
8854
8855rule__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;
8866finally {
8867 restoreStackSize(stackSize);
8868}
8869
8870rule__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;
8881finally {
8882 restoreStackSize(stackSize);
8883}
8884
8885rule__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;
8896finally {
8897 restoreStackSize(stackSize);
8898}
8899
8900rule__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;
8915finally {
8916 restoreStackSize(stackSize);
8917}
8918
8919rule__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;
8934finally {
8935 restoreStackSize(stackSize);
8936}
8937
8938rule__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;
8949finally {
8950 restoreStackSize(stackSize);
8951}
8952
8953rule__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;
8964finally {
8965 restoreStackSize(stackSize);
8966}
8967
8968rule__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;
8979finally {
8980 restoreStackSize(stackSize);
8981}
8982
8983rule__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;
8998finally {
8999 restoreStackSize(stackSize);
9000}
9001
9002rule__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;
9017finally {
9018 restoreStackSize(stackSize);
9019}
9020
9021rule__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;
9032finally {
9033 restoreStackSize(stackSize);
9034}
9035
9036rule__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;
9047finally {
9048 restoreStackSize(stackSize);
9049}
9050
9051rule__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;
9062finally {
9063 restoreStackSize(stackSize);
9064}
9065
9066rule__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;
9081finally {
9082 restoreStackSize(stackSize);
9083}
9084
9085rule__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;
9100finally {
9101 restoreStackSize(stackSize);
9102}
9103
9104rule__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;
9115finally {
9116 restoreStackSize(stackSize);
9117}
9118
9119rule__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;
9130finally {
9131 restoreStackSize(stackSize);
9132}
9133
9134rule__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;
9145finally {
9146 restoreStackSize(stackSize);
9147}
9148
9149rule__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;
9160finally {
9161 restoreStackSize(stackSize);
9162}
9163
9164rule__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;
9179finally {
9180 restoreStackSize(stackSize);
9181}
9182
9183rule__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;
9198finally {
9199 restoreStackSize(stackSize);
9200}
9201
9202rule__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;
9213finally {
9214 restoreStackSize(stackSize);
9215}
9216
9217rule__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;
9228finally {
9229 restoreStackSize(stackSize);
9230}
9231
9232rule__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;
9243finally {
9244 restoreStackSize(stackSize);
9245}
9246
9247rule__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;
9258finally {
9259 restoreStackSize(stackSize);
9260}
9261
9262rule__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;
9277finally {
9278 restoreStackSize(stackSize);
9279}
9280
9281rule__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;
9296finally {
9297 restoreStackSize(stackSize);
9298}
9299
9300rule__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;
9311finally {
9312 restoreStackSize(stackSize);
9313}
9314
9315rule__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;
9326finally {
9327 restoreStackSize(stackSize);
9328}
9329
9330rule__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;
9341finally {
9342 restoreStackSize(stackSize);
9343}
9344
9345rule__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;
9356finally {
9357 restoreStackSize(stackSize);
9358}
9359
9360rule__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;
9371finally {
9372 restoreStackSize(stackSize);
9373}
9374
9375rule__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;
9390finally {
9391 restoreStackSize(stackSize);
9392}
9393
9394rule__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;
9405finally {
9406 restoreStackSize(stackSize);
9407}
9408
9409rule__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;
9420finally {
9421 restoreStackSize(stackSize);
9422}
9423
9424rule__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;
9439finally {
9440 restoreStackSize(stackSize);
9441}
9442
9443rule__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;
9454finally {
9455 restoreStackSize(stackSize);
9456}
9457
9458rule__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;
9469finally {
9470 restoreStackSize(stackSize);
9471}
9472
9473rule__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;
9484finally {
9485 restoreStackSize(stackSize);
9486}
9487
9488rule__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;
9499finally {
9500 restoreStackSize(stackSize);
9501}
9502
9503rule__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;
9514finally {
9515 restoreStackSize(stackSize);
9516}
9517
9518rule__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;
9529finally {
9530 restoreStackSize(stackSize);
9531}
9532
9533rule__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;
9544finally {
9545 restoreStackSize(stackSize);
9546}
9547
9548rule__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;
9559finally {
9560 restoreStackSize(stackSize);
9561}
9562
9563rule__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;
9578finally {
9579 restoreStackSize(stackSize);
9580}
9581
9582rule__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;
9593finally {
9594 restoreStackSize(stackSize);
9595}
9596
9597rule__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;
9608finally {
9609 restoreStackSize(stackSize);
9610}
9611
9612rule__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;
9623finally {
9624 restoreStackSize(stackSize);
9625}
9626
9627rule__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;
9638finally {
9639 restoreStackSize(stackSize);
9640}
9641
9642rule__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;
9657finally {
9658 restoreStackSize(stackSize);
9659}
9660
9661rule__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;
9672finally {
9673 restoreStackSize(stackSize);
9674}
9675
9676rule__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;
9691finally {
9692 restoreStackSize(stackSize);
9693}
9694
9695rule__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;
9706finally {
9707 restoreStackSize(stackSize);
9708}
9709
9710rule__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;
9721finally {
9722 restoreStackSize(stackSize);
9723}
9724
9725rule__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;
9736finally {
9737 restoreStackSize(stackSize);
9738}
9739
9740rule__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;
9751finally {
9752 restoreStackSize(stackSize);
9753}
9754
9755rule__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;
9766finally {
9767 restoreStackSize(stackSize);
9768}
9769
9770rule__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;
9781finally {
9782 restoreStackSize(stackSize);
9783}
9784
9785rule__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;
9796finally {
9797 restoreStackSize(stackSize);
9798}
9799
1565RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; 9800RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
1566 9801
1567RULE_INT : ('0'..'9')+; 9802RULE_INT : ('0'..'9')+;
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-18 10:11:17 +0000