1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 package org.apache.directory.api.ldap.aci;
25
26
27 import org.apache.directory.api.ldap.model.schema.normalizers.NameComponentNormalizer;
28
29 import antlr.TokenBuffer;
30 import antlr.TokenStreamException;
31 import antlr.TokenStreamIOException;
32 import antlr.ANTLRException;
33 import antlr.LLkParser;
34 import antlr.Token;
35 import antlr.TokenStream;
36 import antlr.RecognitionException;
37 import antlr.NoViableAltException;
38 import antlr.MismatchedTokenException;
39 import antlr.SemanticException;
40 import antlr.ParserSharedInputState;
41 import antlr.collections.impl.BitSet;
42
43
44
45
46
47
48 public class AntlrACIItemChecker extends antlr.LLkParser implements AntlrACIItemCheckerTokenTypes
49 {
50
51 NameComponentNormalizer normalizer;
52
53
54
55
56
57
58
59
60 public void init()
61 {
62 }
63
64
65
66
67 public void setNormalizer(NameComponentNormalizer normalizer)
68 {
69 this.normalizer = normalizer;
70 }
71
72 protected AntlrACIItemChecker(TokenBuffer tokenBuf, int k) {
73 super(tokenBuf,k);
74 tokenNames = _tokenNames;
75 }
76
77 public AntlrACIItemChecker(TokenBuffer tokenBuf) {
78 this(tokenBuf,1);
79 }
80
81 protected AntlrACIItemChecker(TokenStream lexer, int k) {
82 super(lexer,k);
83 tokenNames = _tokenNames;
84 }
85
86 public AntlrACIItemChecker(TokenStream lexer) {
87 this(lexer,1);
88 }
89
90 public AntlrACIItemChecker(ParserSharedInputState state) {
91 super(state,1);
92 tokenNames = _tokenNames;
93 }
94
95 public final void wrapperEntryPoint() throws RecognitionException, TokenStreamException {
96
97
98 {
99 _loop3:
100 do {
101 if ((LA(1)==SP)) {
102 match(SP);
103 }
104 else {
105 break _loop3;
106 }
107
108 } while (true);
109 }
110 theACIItem();
111 {
112 _loop5:
113 do {
114 if ((LA(1)==SP)) {
115 match(SP);
116 }
117 else {
118 break _loop5;
119 }
120
121 } while (true);
122 }
123 match(Token.EOF_TYPE);
124 }
125
126 public final void theACIItem() throws RecognitionException, TokenStreamException {
127
128
129 match(OPEN_CURLY);
130 {
131 _loop8:
132 do {
133 if ((LA(1)==SP)) {
134 match(SP);
135 }
136 else {
137 break _loop8;
138 }
139
140 } while (true);
141 }
142 mainACIItemComponent();
143 {
144 _loop10:
145 do {
146 if ((LA(1)==SP)) {
147 match(SP);
148 }
149 else {
150 break _loop10;
151 }
152
153 } while (true);
154 }
155 {
156 _loop16:
157 do {
158 if ((LA(1)==SEP)) {
159 match(SEP);
160 {
161 _loop13:
162 do {
163 if ((LA(1)==SP)) {
164 match(SP);
165 }
166 else {
167 break _loop13;
168 }
169
170 } while (true);
171 }
172 mainACIItemComponent();
173 {
174 _loop15:
175 do {
176 if ((LA(1)==SP)) {
177 match(SP);
178 }
179 else {
180 break _loop15;
181 }
182
183 } while (true);
184 }
185 }
186 else {
187 break _loop16;
188 }
189
190 } while (true);
191 }
192 match(CLOSE_CURLY);
193 }
194
195 public final void mainACIItemComponent() throws RecognitionException, TokenStreamException {
196
197
198 switch ( LA(1)) {
199 case ID_identificationTag:
200 {
201 aci_identificationTag();
202 break;
203 }
204 case ID_precedence:
205 {
206 aci_precedence();
207 break;
208 }
209 case ID_authenticationLevel:
210 {
211 aci_authenticationLevel();
212 break;
213 }
214 case ID_itemOrUserFirst:
215 {
216 aci_itemOrUserFirst();
217 break;
218 }
219 default:
220 {
221 throw new NoViableAltException(LT(1), getFilename());
222 }
223 }
224 }
225
226 public final void aci_identificationTag() throws RecognitionException, TokenStreamException {
227
228
229 match(ID_identificationTag);
230 {
231 int _cnt20=0;
232 _loop20:
233 do {
234 if ((LA(1)==SP)) {
235 match(SP);
236 }
237 else {
238 if ( _cnt20>=1 ) { break _loop20; } else {throw new NoViableAltException(LT(1), getFilename());}
239 }
240
241 _cnt20++;
242 } while (true);
243 }
244 match(SAFEUTF8STRING);
245 }
246
247 public final void aci_precedence() throws RecognitionException, TokenStreamException {
248
249
250 precedence();
251 }
252
253 public final void aci_authenticationLevel() throws RecognitionException, TokenStreamException {
254
255
256 match(ID_authenticationLevel);
257 {
258 int _cnt27=0;
259 _loop27:
260 do {
261 if ((LA(1)==SP)) {
262 match(SP);
263 }
264 else {
265 if ( _cnt27>=1 ) { break _loop27; } else {throw new NoViableAltException(LT(1), getFilename());}
266 }
267
268 _cnt27++;
269 } while (true);
270 }
271 authenticationLevel();
272 }
273
274 public final void aci_itemOrUserFirst() throws RecognitionException, TokenStreamException {
275
276
277 match(ID_itemOrUserFirst);
278 {
279 int _cnt31=0;
280 _loop31:
281 do {
282 if ((LA(1)==SP)) {
283 match(SP);
284 }
285 else {
286 if ( _cnt31>=1 ) { break _loop31; } else {throw new NoViableAltException(LT(1), getFilename());}
287 }
288
289 _cnt31++;
290 } while (true);
291 }
292 itemOrUserFirst();
293 }
294
295 public final void precedence() throws RecognitionException, TokenStreamException {
296
297
298 match(ID_precedence);
299 {
300 int _cnt24=0;
301 _loop24:
302 do {
303 if ((LA(1)==SP)) {
304 match(SP);
305 }
306 else {
307 if ( _cnt24>=1 ) { break _loop24; } else {throw new NoViableAltException(LT(1), getFilename());}
308 }
309
310 _cnt24++;
311 } while (true);
312 }
313 match(INTEGER);
314 }
315
316 public final void authenticationLevel() throws RecognitionException, TokenStreamException {
317
318
319 switch ( LA(1)) {
320 case ID_none:
321 {
322 match(ID_none);
323 break;
324 }
325 case ID_simple:
326 {
327 match(ID_simple);
328 break;
329 }
330 case ID_strong:
331 {
332 match(ID_strong);
333 break;
334 }
335 default:
336 {
337 throw new NoViableAltException(LT(1), getFilename());
338 }
339 }
340 }
341
342 public final void itemOrUserFirst() throws RecognitionException, TokenStreamException {
343
344
345 switch ( LA(1)) {
346 case ID_itemFirst:
347 {
348 itemFirst();
349 break;
350 }
351 case ID_userFirst:
352 {
353 userFirst();
354 break;
355 }
356 default:
357 {
358 throw new NoViableAltException(LT(1), getFilename());
359 }
360 }
361 }
362
363 public final void itemFirst() throws RecognitionException, TokenStreamException {
364
365
366 match(ID_itemFirst);
367 {
368 _loop35:
369 do {
370 if ((LA(1)==SP)) {
371 match(SP);
372 }
373 else {
374 break _loop35;
375 }
376
377 } while (true);
378 }
379 match(COLON);
380 {
381 _loop37:
382 do {
383 if ((LA(1)==SP)) {
384 match(SP);
385 }
386 else {
387 break _loop37;
388 }
389
390 } while (true);
391 }
392 match(OPEN_CURLY);
393 {
394 _loop39:
395 do {
396 if ((LA(1)==SP)) {
397 match(SP);
398 }
399 else {
400 break _loop39;
401 }
402
403 } while (true);
404 }
405 {
406 switch ( LA(1)) {
407 case ID_protectedItems:
408 {
409 protectedItems();
410 {
411 _loop42:
412 do {
413 if ((LA(1)==SP)) {
414 match(SP);
415 }
416 else {
417 break _loop42;
418 }
419
420 } while (true);
421 }
422 match(SEP);
423 {
424 _loop44:
425 do {
426 if ((LA(1)==SP)) {
427 match(SP);
428 }
429 else {
430 break _loop44;
431 }
432
433 } while (true);
434 }
435 itemPermissions();
436 break;
437 }
438 case ID_itemPermissions:
439 {
440 itemPermissions();
441 {
442 _loop46:
443 do {
444 if ((LA(1)==SP)) {
445 match(SP);
446 }
447 else {
448 break _loop46;
449 }
450
451 } while (true);
452 }
453 match(SEP);
454 {
455 _loop48:
456 do {
457 if ((LA(1)==SP)) {
458 match(SP);
459 }
460 else {
461 break _loop48;
462 }
463
464 } while (true);
465 }
466 protectedItems();
467 break;
468 }
469 default:
470 {
471 throw new NoViableAltException(LT(1), getFilename());
472 }
473 }
474 }
475 {
476 _loop50:
477 do {
478 if ((LA(1)==SP)) {
479 match(SP);
480 }
481 else {
482 break _loop50;
483 }
484
485 } while (true);
486 }
487 match(CLOSE_CURLY);
488 }
489
490 public final void userFirst() throws RecognitionException, TokenStreamException {
491
492
493 match(ID_userFirst);
494 {
495 _loop53:
496 do {
497 if ((LA(1)==SP)) {
498 match(SP);
499 }
500 else {
501 break _loop53;
502 }
503
504 } while (true);
505 }
506 match(COLON);
507 {
508 _loop55:
509 do {
510 if ((LA(1)==SP)) {
511 match(SP);
512 }
513 else {
514 break _loop55;
515 }
516
517 } while (true);
518 }
519 match(OPEN_CURLY);
520 {
521 _loop57:
522 do {
523 if ((LA(1)==SP)) {
524 match(SP);
525 }
526 else {
527 break _loop57;
528 }
529
530 } while (true);
531 }
532 {
533 switch ( LA(1)) {
534 case ID_userClasses:
535 {
536 userClasses();
537 {
538 _loop60:
539 do {
540 if ((LA(1)==SP)) {
541 match(SP);
542 }
543 else {
544 break _loop60;
545 }
546
547 } while (true);
548 }
549 match(SEP);
550 {
551 _loop62:
552 do {
553 if ((LA(1)==SP)) {
554 match(SP);
555 }
556 else {
557 break _loop62;
558 }
559
560 } while (true);
561 }
562 userPermissions();
563 break;
564 }
565 case ID_userPermissions:
566 {
567 userPermissions();
568 {
569 _loop64:
570 do {
571 if ((LA(1)==SP)) {
572 match(SP);
573 }
574 else {
575 break _loop64;
576 }
577
578 } while (true);
579 }
580 match(SEP);
581 {
582 _loop66:
583 do {
584 if ((LA(1)==SP)) {
585 match(SP);
586 }
587 else {
588 break _loop66;
589 }
590
591 } while (true);
592 }
593 userClasses();
594 break;
595 }
596 default:
597 {
598 throw new NoViableAltException(LT(1), getFilename());
599 }
600 }
601 }
602 {
603 _loop68:
604 do {
605 if ((LA(1)==SP)) {
606 match(SP);
607 }
608 else {
609 break _loop68;
610 }
611
612 } while (true);
613 }
614 match(CLOSE_CURLY);
615 }
616
617 public final void protectedItems() throws RecognitionException, TokenStreamException {
618
619
620 match(ID_protectedItems);
621 {
622 _loop71:
623 do {
624 if ((LA(1)==SP)) {
625 match(SP);
626 }
627 else {
628 break _loop71;
629 }
630
631 } while (true);
632 }
633 match(OPEN_CURLY);
634 {
635 _loop73:
636 do {
637 if ((LA(1)==SP)) {
638 match(SP);
639 }
640 else {
641 break _loop73;
642 }
643
644 } while (true);
645 }
646 {
647 switch ( LA(1)) {
648 case ATTRIBUTE_VALUE_CANDIDATE:
649 case RANGE_OF_VALUES_CANDIDATE:
650 case ID_entry:
651 case ID_allUserAttributeTypes:
652 case ID_attributeType:
653 case ID_allAttributeValues:
654 case ID_allUserAttributeTypesAndValues:
655 case ID_selfValue:
656 case ID_maxValueCount:
657 case ID_maxImmSub:
658 case ID_restrictedBy:
659 case ID_classes:
660 {
661 protectedItem();
662 {
663 _loop76:
664 do {
665 if ((LA(1)==SP)) {
666 match(SP);
667 }
668 else {
669 break _loop76;
670 }
671
672 } while (true);
673 }
674 {
675 _loop82:
676 do {
677 if ((LA(1)==SEP)) {
678 match(SEP);
679 {
680 _loop79:
681 do {
682 if ((LA(1)==SP)) {
683 match(SP);
684 }
685 else {
686 break _loop79;
687 }
688
689 } while (true);
690 }
691 protectedItem();
692 {
693 _loop81:
694 do {
695 if ((LA(1)==SP)) {
696 match(SP);
697 }
698 else {
699 break _loop81;
700 }
701
702 } while (true);
703 }
704 }
705 else {
706 break _loop82;
707 }
708
709 } while (true);
710 }
711 break;
712 }
713 case CLOSE_CURLY:
714 {
715 break;
716 }
717 default:
718 {
719 throw new NoViableAltException(LT(1), getFilename());
720 }
721 }
722 }
723 match(CLOSE_CURLY);
724 }
725
726 public final void itemPermissions() throws RecognitionException, TokenStreamException {
727
728
729 match(ID_itemPermissions);
730 {
731 int _cnt187=0;
732 _loop187:
733 do {
734 if ((LA(1)==SP)) {
735 match(SP);
736 }
737 else {
738 if ( _cnt187>=1 ) { break _loop187; } else {throw new NoViableAltException(LT(1), getFilename());}
739 }
740
741 _cnt187++;
742 } while (true);
743 }
744 match(OPEN_CURLY);
745 {
746 _loop189:
747 do {
748 if ((LA(1)==SP)) {
749 match(SP);
750 }
751 else {
752 break _loop189;
753 }
754
755 } while (true);
756 }
757 {
758 switch ( LA(1)) {
759 case OPEN_CURLY:
760 {
761 itemPermission();
762 {
763 _loop192:
764 do {
765 if ((LA(1)==SP)) {
766 match(SP);
767 }
768 else {
769 break _loop192;
770 }
771
772 } while (true);
773 }
774 {
775 _loop198:
776 do {
777 if ((LA(1)==SEP)) {
778 match(SEP);
779 {
780 _loop195:
781 do {
782 if ((LA(1)==SP)) {
783 match(SP);
784 }
785 else {
786 break _loop195;
787 }
788
789 } while (true);
790 }
791 itemPermission();
792 {
793 _loop197:
794 do {
795 if ((LA(1)==SP)) {
796 match(SP);
797 }
798 else {
799 break _loop197;
800 }
801
802 } while (true);
803 }
804 }
805 else {
806 break _loop198;
807 }
808
809 } while (true);
810 }
811 break;
812 }
813 case CLOSE_CURLY:
814 {
815 break;
816 }
817 default:
818 {
819 throw new NoViableAltException(LT(1), getFilename());
820 }
821 }
822 }
823 match(CLOSE_CURLY);
824 }
825
826 public final void userClasses() throws RecognitionException, TokenStreamException {
827
828
829 match(ID_userClasses);
830 {
831 int _cnt228=0;
832 _loop228:
833 do {
834 if ((LA(1)==SP)) {
835 match(SP);
836 }
837 else {
838 if ( _cnt228>=1 ) { break _loop228; } else {throw new NoViableAltException(LT(1), getFilename());}
839 }
840
841 _cnt228++;
842 } while (true);
843 }
844 match(OPEN_CURLY);
845 {
846 _loop230:
847 do {
848 if ((LA(1)==SP)) {
849 match(SP);
850 }
851 else {
852 break _loop230;
853 }
854
855 } while (true);
856 }
857 {
858 switch ( LA(1)) {
859 case ID_allUsers:
860 case ID_thisEntry:
861 case ID_parentOfEntry:
862 case ID_name:
863 case ID_userGroup:
864 case ID_subtree:
865 {
866 userClass();
867 {
868 _loop233:
869 do {
870 if ((LA(1)==SP)) {
871 match(SP);
872 }
873 else {
874 break _loop233;
875 }
876
877 } while (true);
878 }
879 {
880 _loop239:
881 do {
882 if ((LA(1)==SEP)) {
883 match(SEP);
884 {
885 _loop236:
886 do {
887 if ((LA(1)==SP)) {
888 match(SP);
889 }
890 else {
891 break _loop236;
892 }
893
894 } while (true);
895 }
896 userClass();
897 {
898 _loop238:
899 do {
900 if ((LA(1)==SP)) {
901 match(SP);
902 }
903 else {
904 break _loop238;
905 }
906
907 } while (true);
908 }
909 }
910 else {
911 break _loop239;
912 }
913
914 } while (true);
915 }
916 break;
917 }
918 case CLOSE_CURLY:
919 {
920 break;
921 }
922 default:
923 {
924 throw new NoViableAltException(LT(1), getFilename());
925 }
926 }
927 }
928 match(CLOSE_CURLY);
929 }
930
931 public final void userPermissions() throws RecognitionException, TokenStreamException {
932
933
934 match(ID_userPermissions);
935 {
936 int _cnt285=0;
937 _loop285:
938 do {
939 if ((LA(1)==SP)) {
940 match(SP);
941 }
942 else {
943 if ( _cnt285>=1 ) { break _loop285; } else {throw new NoViableAltException(LT(1), getFilename());}
944 }
945
946 _cnt285++;
947 } while (true);
948 }
949 match(OPEN_CURLY);
950 {
951 _loop287:
952 do {
953 if ((LA(1)==SP)) {
954 match(SP);
955 }
956 else {
957 break _loop287;
958 }
959
960 } while (true);
961 }
962 {
963 switch ( LA(1)) {
964 case OPEN_CURLY:
965 {
966 userPermission();
967 {
968 _loop290:
969 do {
970 if ((LA(1)==SP)) {
971 match(SP);
972 }
973 else {
974 break _loop290;
975 }
976
977 } while (true);
978 }
979 {
980 _loop296:
981 do {
982 if ((LA(1)==SEP)) {
983 match(SEP);
984 {
985 _loop293:
986 do {
987 if ((LA(1)==SP)) {
988 match(SP);
989 }
990 else {
991 break _loop293;
992 }
993
994 } while (true);
995 }
996 userPermission();
997 {
998 _loop295:
999 do {
1000 if ((LA(1)==SP)) {
1001 match(SP);
1002 }
1003 else {
1004 break _loop295;
1005 }
1006
1007 } while (true);
1008 }
1009 }
1010 else {
1011 break _loop296;
1012 }
1013
1014 } while (true);
1015 }
1016 break;
1017 }
1018 case CLOSE_CURLY:
1019 {
1020 break;
1021 }
1022 default:
1023 {
1024 throw new NoViableAltException(LT(1), getFilename());
1025 }
1026 }
1027 }
1028 match(CLOSE_CURLY);
1029 }
1030
1031 public final void protectedItem() throws RecognitionException, TokenStreamException {
1032
1033
1034 switch ( LA(1)) {
1035 case ID_entry:
1036 {
1037 entry();
1038 break;
1039 }
1040 case ID_allUserAttributeTypes:
1041 {
1042 allUserAttributeTypes();
1043 break;
1044 }
1045 case ID_attributeType:
1046 {
1047 attributeType();
1048 break;
1049 }
1050 case ID_allAttributeValues:
1051 {
1052 allAttributeValues();
1053 break;
1054 }
1055 case ID_allUserAttributeTypesAndValues:
1056 {
1057 allUserAttributeTypesAndValues();
1058 break;
1059 }
1060 case ATTRIBUTE_VALUE_CANDIDATE:
1061 {
1062 attributeValue();
1063 break;
1064 }
1065 case ID_selfValue:
1066 {
1067 selfValue();
1068 break;
1069 }
1070 case RANGE_OF_VALUES_CANDIDATE:
1071 {
1072 rangeOfValues();
1073 break;
1074 }
1075 case ID_maxValueCount:
1076 {
1077 maxValueCount();
1078 break;
1079 }
1080 case ID_maxImmSub:
1081 {
1082 maxImmSub();
1083 break;
1084 }
1085 case ID_restrictedBy:
1086 {
1087 restrictedBy();
1088 break;
1089 }
1090 case ID_classes:
1091 {
1092 classes();
1093 break;
1094 }
1095 default:
1096 {
1097 throw new NoViableAltException(LT(1), getFilename());
1098 }
1099 }
1100 }
1101
1102 public final void entry() throws RecognitionException, TokenStreamException {
1103
1104
1105 match(ID_entry);
1106 }
1107
1108 public final void allUserAttributeTypes() throws RecognitionException, TokenStreamException {
1109
1110
1111 match(ID_allUserAttributeTypes);
1112 }
1113
1114 public final void attributeType() throws RecognitionException, TokenStreamException {
1115
1116
1117 match(ID_attributeType);
1118 {
1119 int _cnt88=0;
1120 _loop88:
1121 do {
1122 if ((LA(1)==SP)) {
1123 match(SP);
1124 }
1125 else {
1126 if ( _cnt88>=1 ) { break _loop88; } else {throw new NoViableAltException(LT(1), getFilename());}
1127 }
1128
1129 _cnt88++;
1130 } while (true);
1131 }
1132 attributeTypeSet();
1133 }
1134
1135 public final void allAttributeValues() throws RecognitionException, TokenStreamException {
1136
1137
1138 match(ID_allAttributeValues);
1139 {
1140 int _cnt91=0;
1141 _loop91:
1142 do {
1143 if ((LA(1)==SP)) {
1144 match(SP);
1145 }
1146 else {
1147 if ( _cnt91>=1 ) { break _loop91; } else {throw new NoViableAltException(LT(1), getFilename());}
1148 }
1149
1150 _cnt91++;
1151 } while (true);
1152 }
1153 attributeTypeSet();
1154 }
1155
1156 public final void allUserAttributeTypesAndValues() throws RecognitionException, TokenStreamException {
1157
1158
1159 match(ID_allUserAttributeTypesAndValues);
1160 }
1161
1162 public final void attributeValue() throws RecognitionException, TokenStreamException {
1163
1164
1165 match(ATTRIBUTE_VALUE_CANDIDATE);
1166 }
1167
1168 public final void selfValue() throws RecognitionException, TokenStreamException {
1169
1170
1171 match(ID_selfValue);
1172 {
1173 int _cnt96=0;
1174 _loop96:
1175 do {
1176 if ((LA(1)==SP)) {
1177 match(SP);
1178 }
1179 else {
1180 if ( _cnt96>=1 ) { break _loop96; } else {throw new NoViableAltException(LT(1), getFilename());}
1181 }
1182
1183 _cnt96++;
1184 } while (true);
1185 }
1186 attributeTypeSet();
1187 }
1188
1189 public final void rangeOfValues() throws RecognitionException, TokenStreamException {
1190
1191
1192 match(RANGE_OF_VALUES_CANDIDATE);
1193 }
1194
1195 public final void maxValueCount() throws RecognitionException, TokenStreamException {
1196
1197
1198 match(ID_maxValueCount);
1199 {
1200 int _cnt100=0;
1201 _loop100:
1202 do {
1203 if ((LA(1)==SP)) {
1204 match(SP);
1205 }
1206 else {
1207 if ( _cnt100>=1 ) { break _loop100; } else {throw new NoViableAltException(LT(1), getFilename());}
1208 }
1209
1210 _cnt100++;
1211 } while (true);
1212 }
1213 match(OPEN_CURLY);
1214 {
1215 _loop102:
1216 do {
1217 if ((LA(1)==SP)) {
1218 match(SP);
1219 }
1220 else {
1221 break _loop102;
1222 }
1223
1224 } while (true);
1225 }
1226 aMaxValueCount();
1227 {
1228 _loop104:
1229 do {
1230 if ((LA(1)==SP)) {
1231 match(SP);
1232 }
1233 else {
1234 break _loop104;
1235 }
1236
1237 } while (true);
1238 }
1239 {
1240 _loop110:
1241 do {
1242 if ((LA(1)==SEP)) {
1243 match(SEP);
1244 {
1245 _loop107:
1246 do {
1247 if ((LA(1)==SP)) {
1248 match(SP);
1249 }
1250 else {
1251 break _loop107;
1252 }
1253
1254 } while (true);
1255 }
1256 aMaxValueCount();
1257 {
1258 _loop109:
1259 do {
1260 if ((LA(1)==SP)) {
1261 match(SP);
1262 }
1263 else {
1264 break _loop109;
1265 }
1266
1267 } while (true);
1268 }
1269 }
1270 else {
1271 break _loop110;
1272 }
1273
1274 } while (true);
1275 }
1276 match(CLOSE_CURLY);
1277 }
1278
1279 public final void maxImmSub() throws RecognitionException, TokenStreamException {
1280
1281
1282 match(ID_maxImmSub);
1283 {
1284 int _cnt135=0;
1285 _loop135:
1286 do {
1287 if ((LA(1)==SP)) {
1288 match(SP);
1289 }
1290 else {
1291 if ( _cnt135>=1 ) { break _loop135; } else {throw new NoViableAltException(LT(1), getFilename());}
1292 }
1293
1294 _cnt135++;
1295 } while (true);
1296 }
1297 match(INTEGER);
1298 }
1299
1300 public final void restrictedBy() throws RecognitionException, TokenStreamException {
1301
1302
1303 match(ID_restrictedBy);
1304 {
1305 int _cnt138=0;
1306 _loop138:
1307 do {
1308 if ((LA(1)==SP)) {
1309 match(SP);
1310 }
1311 else {
1312 if ( _cnt138>=1 ) { break _loop138; } else {throw new NoViableAltException(LT(1), getFilename());}
1313 }
1314
1315 _cnt138++;
1316 } while (true);
1317 }
1318 match(OPEN_CURLY);
1319 {
1320 _loop140:
1321 do {
1322 if ((LA(1)==SP)) {
1323 match(SP);
1324 }
1325 else {
1326 break _loop140;
1327 }
1328
1329 } while (true);
1330 }
1331 restrictedValue();
1332 {
1333 _loop142:
1334 do {
1335 if ((LA(1)==SP)) {
1336 match(SP);
1337 }
1338 else {
1339 break _loop142;
1340 }
1341
1342 } while (true);
1343 }
1344 {
1345 _loop148:
1346 do {
1347 if ((LA(1)==SEP)) {
1348 match(SEP);
1349 {
1350 _loop145:
1351 do {
1352 if ((LA(1)==SP)) {
1353 match(SP);
1354 }
1355 else {
1356 break _loop145;
1357 }
1358
1359 } while (true);
1360 }
1361 restrictedValue();
1362 {
1363 _loop147:
1364 do {
1365 if ((LA(1)==SP)) {
1366 match(SP);
1367 }
1368 else {
1369 break _loop147;
1370 }
1371
1372 } while (true);
1373 }
1374 }
1375 else {
1376 break _loop148;
1377 }
1378
1379 } while (true);
1380 }
1381 match(CLOSE_CURLY);
1382 }
1383
1384 public final void classes() throws RecognitionException, TokenStreamException {
1385
1386
1387 match(ID_classes);
1388 {
1389 int _cnt184=0;
1390 _loop184:
1391 do {
1392 if ((LA(1)==SP)) {
1393 match(SP);
1394 }
1395 else {
1396 if ( _cnt184>=1 ) { break _loop184; } else {throw new NoViableAltException(LT(1), getFilename());}
1397 }
1398
1399 _cnt184++;
1400 } while (true);
1401 }
1402 refinement();
1403 }
1404
1405 public final void attributeTypeSet() throws RecognitionException, TokenStreamException {
1406
1407
1408 match(OPEN_CURLY);
1409 {
1410 _loop173:
1411 do {
1412 if ((LA(1)==SP)) {
1413 match(SP);
1414 }
1415 else {
1416 break _loop173;
1417 }
1418
1419 } while (true);
1420 }
1421 oid();
1422 {
1423 _loop175:
1424 do {
1425 if ((LA(1)==SP)) {
1426 match(SP);
1427 }
1428 else {
1429 break _loop175;
1430 }
1431
1432 } while (true);
1433 }
1434 {
1435 _loop181:
1436 do {
1437 if ((LA(1)==SEP)) {
1438 match(SEP);
1439 {
1440 _loop178:
1441 do {
1442 if ((LA(1)==SP)) {
1443 match(SP);
1444 }
1445 else {
1446 break _loop178;
1447 }
1448
1449 } while (true);
1450 }
1451 oid();
1452 {
1453 _loop180:
1454 do {
1455 if ((LA(1)==SP)) {
1456 match(SP);
1457 }
1458 else {
1459 break _loop180;
1460 }
1461
1462 } while (true);
1463 }
1464 }
1465 else {
1466 break _loop181;
1467 }
1468
1469 } while (true);
1470 }
1471 match(CLOSE_CURLY);
1472 }
1473
1474 public final void aMaxValueCount() throws RecognitionException, TokenStreamException {
1475
1476
1477 match(OPEN_CURLY);
1478 {
1479 _loop113:
1480 do {
1481 if ((LA(1)==SP)) {
1482 match(SP);
1483 }
1484 else {
1485 break _loop113;
1486 }
1487
1488 } while (true);
1489 }
1490 {
1491 switch ( LA(1)) {
1492 case ID_type:
1493 {
1494 match(ID_type);
1495 {
1496 int _cnt116=0;
1497 _loop116:
1498 do {
1499 if ((LA(1)==SP)) {
1500 match(SP);
1501 }
1502 else {
1503 if ( _cnt116>=1 ) { break _loop116; } else {throw new NoViableAltException(LT(1), getFilename());}
1504 }
1505
1506 _cnt116++;
1507 } while (true);
1508 }
1509 oid();
1510 {
1511 _loop118:
1512 do {
1513 if ((LA(1)==SP)) {
1514 match(SP);
1515 }
1516 else {
1517 break _loop118;
1518 }
1519
1520 } while (true);
1521 }
1522 match(SEP);
1523 {
1524 _loop120:
1525 do {
1526 if ((LA(1)==SP)) {
1527 match(SP);
1528 }
1529 else {
1530 break _loop120;
1531 }
1532
1533 } while (true);
1534 }
1535 match(ID_maxCount);
1536 {
1537 int _cnt122=0;
1538 _loop122:
1539 do {
1540 if ((LA(1)==SP)) {
1541 match(SP);
1542 }
1543 else {
1544 if ( _cnt122>=1 ) { break _loop122; } else {throw new NoViableAltException(LT(1), getFilename());}
1545 }
1546
1547 _cnt122++;
1548 } while (true);
1549 }
1550 match(INTEGER);
1551 break;
1552 }
1553 case ID_maxCount:
1554 {
1555 match(ID_maxCount);
1556 {
1557 int _cnt124=0;
1558 _loop124:
1559 do {
1560 if ((LA(1)==SP)) {
1561 match(SP);
1562 }
1563 else {
1564 if ( _cnt124>=1 ) { break _loop124; } else {throw new NoViableAltException(LT(1), getFilename());}
1565 }
1566
1567 _cnt124++;
1568 } while (true);
1569 }
1570 match(INTEGER);
1571 {
1572 _loop126:
1573 do {
1574 if ((LA(1)==SP)) {
1575 match(SP);
1576 }
1577 else {
1578 break _loop126;
1579 }
1580
1581 } while (true);
1582 }
1583 match(SEP);
1584 {
1585 _loop128:
1586 do {
1587 if ((LA(1)==SP)) {
1588 match(SP);
1589 }
1590 else {
1591 break _loop128;
1592 }
1593
1594 } while (true);
1595 }
1596 match(ID_type);
1597 {
1598 int _cnt130=0;
1599 _loop130:
1600 do {
1601 if ((LA(1)==SP)) {
1602 match(SP);
1603 }
1604 else {
1605 if ( _cnt130>=1 ) { break _loop130; } else {throw new NoViableAltException(LT(1), getFilename());}
1606 }
1607
1608 _cnt130++;
1609 } while (true);
1610 }
1611 oid();
1612 break;
1613 }
1614 default:
1615 {
1616 throw new NoViableAltException(LT(1), getFilename());
1617 }
1618 }
1619 }
1620 {
1621 _loop132:
1622 do {
1623 if ((LA(1)==SP)) {
1624 match(SP);
1625 }
1626 else {
1627 break _loop132;
1628 }
1629
1630 } while (true);
1631 }
1632 match(CLOSE_CURLY);
1633 }
1634
1635 public final void oid() throws RecognitionException, TokenStreamException {
1636
1637
1638 {
1639 switch ( LA(1)) {
1640 case DESCR:
1641 {
1642 match(DESCR);
1643 break;
1644 }
1645 case NUMERICOID:
1646 {
1647 match(NUMERICOID);
1648 break;
1649 }
1650 default:
1651 {
1652 throw new NoViableAltException(LT(1), getFilename());
1653 }
1654 }
1655 }
1656 }
1657
1658 public final void restrictedValue() throws RecognitionException, TokenStreamException {
1659
1660
1661 match(OPEN_CURLY);
1662 {
1663 _loop151:
1664 do {
1665 if ((LA(1)==SP)) {
1666 match(SP);
1667 }
1668 else {
1669 break _loop151;
1670 }
1671
1672 } while (true);
1673 }
1674 {
1675 switch ( LA(1)) {
1676 case ID_type:
1677 {
1678 match(ID_type);
1679 {
1680 int _cnt154=0;
1681 _loop154:
1682 do {
1683 if ((LA(1)==SP)) {
1684 match(SP);
1685 }
1686 else {
1687 if ( _cnt154>=1 ) { break _loop154; } else {throw new NoViableAltException(LT(1), getFilename());}
1688 }
1689
1690 _cnt154++;
1691 } while (true);
1692 }
1693 oid();
1694 {
1695 _loop156:
1696 do {
1697 if ((LA(1)==SP)) {
1698 match(SP);
1699 }
1700 else {
1701 break _loop156;
1702 }
1703
1704 } while (true);
1705 }
1706 match(SEP);
1707 {
1708 _loop158:
1709 do {
1710 if ((LA(1)==SP)) {
1711 match(SP);
1712 }
1713 else {
1714 break _loop158;
1715 }
1716
1717 } while (true);
1718 }
1719 match(ID_valuesIn);
1720 {
1721 int _cnt160=0;
1722 _loop160:
1723 do {
1724 if ((LA(1)==SP)) {
1725 match(SP);
1726 }
1727 else {
1728 if ( _cnt160>=1 ) { break _loop160; } else {throw new NoViableAltException(LT(1), getFilename());}
1729 }
1730
1731 _cnt160++;
1732 } while (true);
1733 }
1734 oid();
1735 break;
1736 }
1737 case ID_valuesIn:
1738 {
1739 match(ID_valuesIn);
1740 {
1741 int _cnt162=0;
1742 _loop162:
1743 do {
1744 if ((LA(1)==SP)) {
1745 match(SP);
1746 }
1747 else {
1748 if ( _cnt162>=1 ) { break _loop162; } else {throw new NoViableAltException(LT(1), getFilename());}
1749 }
1750
1751 _cnt162++;
1752 } while (true);
1753 }
1754 oid();
1755 {
1756 _loop164:
1757 do {
1758 if ((LA(1)==SP)) {
1759 match(SP);
1760 }
1761 else {
1762 break _loop164;
1763 }
1764
1765 } while (true);
1766 }
1767 match(SEP);
1768 {
1769 _loop166:
1770 do {
1771 if ((LA(1)==SP)) {
1772 match(SP);
1773 }
1774 else {
1775 break _loop166;
1776 }
1777
1778 } while (true);
1779 }
1780 match(ID_type);
1781 {
1782 int _cnt168=0;
1783 _loop168:
1784 do {
1785 if ((LA(1)==SP)) {
1786 match(SP);
1787 }
1788 else {
1789 if ( _cnt168>=1 ) { break _loop168; } else {throw new NoViableAltException(LT(1), getFilename());}
1790 }
1791
1792 _cnt168++;
1793 } while (true);
1794 }
1795 oid();
1796 break;
1797 }
1798 default:
1799 {
1800 throw new NoViableAltException(LT(1), getFilename());
1801 }
1802 }
1803 }
1804 {
1805 _loop170:
1806 do {
1807 if ((LA(1)==SP)) {
1808 match(SP);
1809 }
1810 else {
1811 break _loop170;
1812 }
1813
1814 } while (true);
1815 }
1816 match(CLOSE_CURLY);
1817 }
1818
1819 public final void refinement() throws RecognitionException, TokenStreamException {
1820
1821
1822 switch ( LA(1)) {
1823 case ID_item:
1824 {
1825 item();
1826 break;
1827 }
1828 case ID_and:
1829 {
1830 and();
1831 break;
1832 }
1833 case ID_or:
1834 {
1835 or();
1836 break;
1837 }
1838 case ID_not:
1839 {
1840 not();
1841 break;
1842 }
1843 default:
1844 {
1845 throw new NoViableAltException(LT(1), getFilename());
1846 }
1847 }
1848 }
1849
1850 public final void itemPermission() throws RecognitionException, TokenStreamException {
1851
1852
1853 match(OPEN_CURLY);
1854 {
1855 _loop201:
1856 do {
1857 if ((LA(1)==SP)) {
1858 match(SP);
1859 }
1860 else {
1861 break _loop201;
1862 }
1863
1864 } while (true);
1865 }
1866 anyItemPermission();
1867 {
1868 _loop203:
1869 do {
1870 if ((LA(1)==SP)) {
1871 match(SP);
1872 }
1873 else {
1874 break _loop203;
1875 }
1876
1877 } while (true);
1878 }
1879 {
1880 _loop209:
1881 do {
1882 if ((LA(1)==SEP)) {
1883 match(SEP);
1884 {
1885 _loop206:
1886 do {
1887 if ((LA(1)==SP)) {
1888 match(SP);
1889 }
1890 else {
1891 break _loop206;
1892 }
1893
1894 } while (true);
1895 }
1896 anyItemPermission();
1897 {
1898 _loop208:
1899 do {
1900 if ((LA(1)==SP)) {
1901 match(SP);
1902 }
1903 else {
1904 break _loop208;
1905 }
1906
1907 } while (true);
1908 }
1909 }
1910 else {
1911 break _loop209;
1912 }
1913
1914 } while (true);
1915 }
1916 match(CLOSE_CURLY);
1917 }
1918
1919 public final void anyItemPermission() throws RecognitionException, TokenStreamException {
1920
1921
1922 switch ( LA(1)) {
1923 case ID_precedence:
1924 {
1925 precedence();
1926 break;
1927 }
1928 case ID_userClasses:
1929 {
1930 userClasses();
1931 break;
1932 }
1933 case ID_grantsAndDenials:
1934 {
1935 grantsAndDenials();
1936 break;
1937 }
1938 default:
1939 {
1940 throw new NoViableAltException(LT(1), getFilename());
1941 }
1942 }
1943 }
1944
1945 public final void grantsAndDenials() throws RecognitionException, TokenStreamException {
1946
1947
1948 match(ID_grantsAndDenials);
1949 {
1950 int _cnt213=0;
1951 _loop213:
1952 do {
1953 if ((LA(1)==SP)) {
1954 match(SP);
1955 }
1956 else {
1957 if ( _cnt213>=1 ) { break _loop213; } else {throw new NoViableAltException(LT(1), getFilename());}
1958 }
1959
1960 _cnt213++;
1961 } while (true);
1962 }
1963 match(OPEN_CURLY);
1964 {
1965 _loop215:
1966 do {
1967 if ((LA(1)==SP)) {
1968 match(SP);
1969 }
1970 else {
1971 break _loop215;
1972 }
1973
1974 } while (true);
1975 }
1976 {
1977 switch ( LA(1)) {
1978 case ID_grantAdd:
1979 case ID_denyAdd:
1980 case ID_grantDiscloseOnError:
1981 case ID_denyDiscloseOnError:
1982 case ID_grantRead:
1983 case ID_denyRead:
1984 case ID_grantRemove:
1985 case ID_denyRemove:
1986 case ID_grantBrowse:
1987 case ID_denyBrowse:
1988 case ID_grantExport:
1989 case ID_denyExport:
1990 case ID_grantImport:
1991 case ID_denyImport:
1992 case ID_grantModify:
1993 case ID_denyModify:
1994 case ID_grantRename:
1995 case ID_denyRename:
1996 case ID_grantReturnDN:
1997 case ID_denyReturnDN:
1998 case ID_grantCompare:
1999 case ID_denyCompare:
2000 case ID_grantFilterMatch:
2001 case ID_denyFilterMatch:
2002 case ID_grantInvoke:
2003 case ID_denyInvoke:
2004 {
2005 grantAndDenial();
2006 {
2007 _loop218:
2008 do {
2009 if ((LA(1)==SP)) {
2010 match(SP);
2011 }
2012 else {
2013 break _loop218;
2014 }
2015
2016 } while (true);
2017 }
2018 {
2019 _loop224:
2020 do {
2021 if ((LA(1)==SEP)) {
2022 match(SEP);
2023 {
2024 _loop221:
2025 do {
2026 if ((LA(1)==SP)) {
2027 match(SP);
2028 }
2029 else {
2030 break _loop221;
2031 }
2032
2033 } while (true);
2034 }
2035 grantAndDenial();
2036 {
2037 _loop223:
2038 do {
2039 if ((LA(1)==SP)) {
2040 match(SP);
2041 }
2042 else {
2043 break _loop223;
2044 }
2045
2046 } while (true);
2047 }
2048 }
2049 else {
2050 break _loop224;
2051 }
2052
2053 } while (true);
2054 }
2055 break;
2056 }
2057 case CLOSE_CURLY:
2058 {
2059 break;
2060 }
2061 default:
2062 {
2063 throw new NoViableAltException(LT(1), getFilename());
2064 }
2065 }
2066 }
2067 match(CLOSE_CURLY);
2068 }
2069
2070 public final void grantAndDenial() throws RecognitionException, TokenStreamException {
2071
2072
2073 switch ( LA(1)) {
2074 case ID_grantAdd:
2075 {
2076 match(ID_grantAdd);
2077 break;
2078 }
2079 case ID_denyAdd:
2080 {
2081 match(ID_denyAdd);
2082 break;
2083 }
2084 case ID_grantDiscloseOnError:
2085 {
2086 match(ID_grantDiscloseOnError);
2087 break;
2088 }
2089 case ID_denyDiscloseOnError:
2090 {
2091 match(ID_denyDiscloseOnError);
2092 break;
2093 }
2094 case ID_grantRead:
2095 {
2096 match(ID_grantRead);
2097 break;
2098 }
2099 case ID_denyRead:
2100 {
2101 match(ID_denyRead);
2102 break;
2103 }
2104 case ID_grantRemove:
2105 {
2106 match(ID_grantRemove);
2107 break;
2108 }
2109 case ID_denyRemove:
2110 {
2111 match(ID_denyRemove);
2112 break;
2113 }
2114 case ID_grantBrowse:
2115 {
2116 match(ID_grantBrowse);
2117 break;
2118 }
2119 case ID_denyBrowse:
2120 {
2121 match(ID_denyBrowse);
2122 break;
2123 }
2124 case ID_grantExport:
2125 {
2126 match(ID_grantExport);
2127 break;
2128 }
2129 case ID_denyExport:
2130 {
2131 match(ID_denyExport);
2132 break;
2133 }
2134 case ID_grantImport:
2135 {
2136 match(ID_grantImport);
2137 break;
2138 }
2139 case ID_denyImport:
2140 {
2141 match(ID_denyImport);
2142 break;
2143 }
2144 case ID_grantModify:
2145 {
2146 match(ID_grantModify);
2147 break;
2148 }
2149 case ID_denyModify:
2150 {
2151 match(ID_denyModify);
2152 break;
2153 }
2154 case ID_grantRename:
2155 {
2156 match(ID_grantRename);
2157 break;
2158 }
2159 case ID_denyRename:
2160 {
2161 match(ID_denyRename);
2162 break;
2163 }
2164 case ID_grantReturnDN:
2165 {
2166 match(ID_grantReturnDN);
2167 break;
2168 }
2169 case ID_denyReturnDN:
2170 {
2171 match(ID_denyReturnDN);
2172 break;
2173 }
2174 case ID_grantCompare:
2175 {
2176 match(ID_grantCompare);
2177 break;
2178 }
2179 case ID_denyCompare:
2180 {
2181 match(ID_denyCompare);
2182 break;
2183 }
2184 case ID_grantFilterMatch:
2185 {
2186 match(ID_grantFilterMatch);
2187 break;
2188 }
2189 case ID_denyFilterMatch:
2190 {
2191 match(ID_denyFilterMatch);
2192 break;
2193 }
2194 case ID_grantInvoke:
2195 {
2196 match(ID_grantInvoke);
2197 break;
2198 }
2199 case ID_denyInvoke:
2200 {
2201 match(ID_denyInvoke);
2202 break;
2203 }
2204 default:
2205 {
2206 throw new NoViableAltException(LT(1), getFilename());
2207 }
2208 }
2209 }
2210
2211 public final void userClass() throws RecognitionException, TokenStreamException {
2212
2213
2214 switch ( LA(1)) {
2215 case ID_allUsers:
2216 {
2217 allUsers();
2218 break;
2219 }
2220 case ID_thisEntry:
2221 {
2222 thisEntry();
2223 break;
2224 }
2225 case ID_parentOfEntry:
2226 {
2227 parentOfEntry();
2228 break;
2229 }
2230 case ID_name:
2231 {
2232 name();
2233 break;
2234 }
2235 case ID_userGroup:
2236 {
2237 userGroup();
2238 break;
2239 }
2240 case ID_subtree:
2241 {
2242 subtree();
2243 break;
2244 }
2245 default:
2246 {
2247 throw new NoViableAltException(LT(1), getFilename());
2248 }
2249 }
2250 }
2251
2252 public final void allUsers() throws RecognitionException, TokenStreamException {
2253
2254
2255 match(ID_allUsers);
2256 }
2257
2258 public final void thisEntry() throws RecognitionException, TokenStreamException {
2259
2260
2261 match(ID_thisEntry);
2262 }
2263
2264 public final void parentOfEntry() throws RecognitionException, TokenStreamException {
2265
2266
2267 match(ID_parentOfEntry);
2268 }
2269
2270 public final void name() throws RecognitionException, TokenStreamException {
2271
2272
2273 match(ID_name);
2274 {
2275 int _cnt246=0;
2276 _loop246:
2277 do {
2278 if ((LA(1)==SP)) {
2279 match(SP);
2280 }
2281 else {
2282 if ( _cnt246>=1 ) { break _loop246; } else {throw new NoViableAltException(LT(1), getFilename());}
2283 }
2284
2285 _cnt246++;
2286 } while (true);
2287 }
2288 match(OPEN_CURLY);
2289 {
2290 _loop248:
2291 do {
2292 if ((LA(1)==SP)) {
2293 match(SP);
2294 }
2295 else {
2296 break _loop248;
2297 }
2298
2299 } while (true);
2300 }
2301 distinguishedName();
2302 {
2303 _loop250:
2304 do {
2305 if ((LA(1)==SP)) {
2306 match(SP);
2307 }
2308 else {
2309 break _loop250;
2310 }
2311
2312 } while (true);
2313 }
2314 {
2315 _loop256:
2316 do {
2317 if ((LA(1)==SEP)) {
2318 match(SEP);
2319 {
2320 _loop253:
2321 do {
2322 if ((LA(1)==SP)) {
2323 match(SP);
2324 }
2325 else {
2326 break _loop253;
2327 }
2328
2329 } while (true);
2330 }
2331 distinguishedName();
2332 {
2333 _loop255:
2334 do {
2335 if ((LA(1)==SP)) {
2336 match(SP);
2337 }
2338 else {
2339 break _loop255;
2340 }
2341
2342 } while (true);
2343 }
2344 }
2345 else {
2346 break _loop256;
2347 }
2348
2349 } while (true);
2350 }
2351 match(CLOSE_CURLY);
2352 }
2353
2354 public final void userGroup() throws RecognitionException, TokenStreamException {
2355
2356
2357 match(ID_userGroup);
2358 {
2359 int _cnt259=0;
2360 _loop259:
2361 do {
2362 if ((LA(1)==SP)) {
2363 match(SP);
2364 }
2365 else {
2366 if ( _cnt259>=1 ) { break _loop259; } else {throw new NoViableAltException(LT(1), getFilename());}
2367 }
2368
2369 _cnt259++;
2370 } while (true);
2371 }
2372 match(OPEN_CURLY);
2373 {
2374 _loop261:
2375 do {
2376 if ((LA(1)==SP)) {
2377 match(SP);
2378 }
2379 else {
2380 break _loop261;
2381 }
2382
2383 } while (true);
2384 }
2385 distinguishedName();
2386 {
2387 _loop263:
2388 do {
2389 if ((LA(1)==SP)) {
2390 match(SP);
2391 }
2392 else {
2393 break _loop263;
2394 }
2395
2396 } while (true);
2397 }
2398 {
2399 _loop269:
2400 do {
2401 if ((LA(1)==SEP)) {
2402 match(SEP);
2403 {
2404 _loop266:
2405 do {
2406 if ((LA(1)==SP)) {
2407 match(SP);
2408 }
2409 else {
2410 break _loop266;
2411 }
2412
2413 } while (true);
2414 }
2415 distinguishedName();
2416 {
2417 _loop268:
2418 do {
2419 if ((LA(1)==SP)) {
2420 match(SP);
2421 }
2422 else {
2423 break _loop268;
2424 }
2425
2426 } while (true);
2427 }
2428 }
2429 else {
2430 break _loop269;
2431 }
2432
2433 } while (true);
2434 }
2435 match(CLOSE_CURLY);
2436 }
2437
2438 public final void subtree() throws RecognitionException, TokenStreamException {
2439
2440
2441 match(ID_subtree);
2442 {
2443 int _cnt272=0;
2444 _loop272:
2445 do {
2446 if ((LA(1)==SP)) {
2447 match(SP);
2448 }
2449 else {
2450 if ( _cnt272>=1 ) { break _loop272; } else {throw new NoViableAltException(LT(1), getFilename());}
2451 }
2452
2453 _cnt272++;
2454 } while (true);
2455 }
2456 match(OPEN_CURLY);
2457 {
2458 _loop274:
2459 do {
2460 if ((LA(1)==SP)) {
2461 match(SP);
2462 }
2463 else {
2464 break _loop274;
2465 }
2466
2467 } while (true);
2468 }
2469 subtreeSpecification();
2470 {
2471 _loop276:
2472 do {
2473 if ((LA(1)==SP)) {
2474 match(SP);
2475 }
2476 else {
2477 break _loop276;
2478 }
2479
2480 } while (true);
2481 }
2482 {
2483 _loop282:
2484 do {
2485 if ((LA(1)==SEP)) {
2486 match(SEP);
2487 {
2488 _loop279:
2489 do {
2490 if ((LA(1)==SP)) {
2491 match(SP);
2492 }
2493 else {
2494 break _loop279;
2495 }
2496
2497 } while (true);
2498 }
2499 subtreeSpecification();
2500 {
2501 _loop281:
2502 do {
2503 if ((LA(1)==SP)) {
2504 match(SP);
2505 }
2506 else {
2507 break _loop281;
2508 }
2509
2510 } while (true);
2511 }
2512 }
2513 else {
2514 break _loop282;
2515 }
2516
2517 } while (true);
2518 }
2519 match(CLOSE_CURLY);
2520 }
2521
2522 public final void distinguishedName() throws RecognitionException, TokenStreamException {
2523
2524
2525 match(SAFEUTF8STRING);
2526 }
2527
2528 public final void subtreeSpecification() throws RecognitionException, TokenStreamException {
2529
2530
2531 match(OPEN_CURLY);
2532 {
2533 _loop311:
2534 do {
2535 if ((LA(1)==SP)) {
2536 match(SP);
2537 }
2538 else {
2539 break _loop311;
2540 }
2541
2542 } while (true);
2543 }
2544 {
2545 switch ( LA(1)) {
2546 case ID_base:
2547 case ID_specificExclusions:
2548 case ID_minimum:
2549 case ID_maximum:
2550 {
2551 subtreeSpecificationComponent();
2552 {
2553 _loop314:
2554 do {
2555 if ((LA(1)==SP)) {
2556 match(SP);
2557 }
2558 else {
2559 break _loop314;
2560 }
2561
2562 } while (true);
2563 }
2564 {
2565 _loop320:
2566 do {
2567 if ((LA(1)==SEP)) {
2568 match(SEP);
2569 {
2570 _loop317:
2571 do {
2572 if ((LA(1)==SP)) {
2573 match(SP);
2574 }
2575 else {
2576 break _loop317;
2577 }
2578
2579 } while (true);
2580 }
2581 subtreeSpecificationComponent();
2582 {
2583 _loop319:
2584 do {
2585 if ((LA(1)==SP)) {
2586 match(SP);
2587 }
2588 else {
2589 break _loop319;
2590 }
2591
2592 } while (true);
2593 }
2594 }
2595 else {
2596 break _loop320;
2597 }
2598
2599 } while (true);
2600 }
2601 break;
2602 }
2603 case CLOSE_CURLY:
2604 {
2605 break;
2606 }
2607 default:
2608 {
2609 throw new NoViableAltException(LT(1), getFilename());
2610 }
2611 }
2612 }
2613 match(CLOSE_CURLY);
2614 }
2615
2616 public final void userPermission() throws RecognitionException, TokenStreamException {
2617
2618
2619 match(OPEN_CURLY);
2620 {
2621 _loop299:
2622 do {
2623 if ((LA(1)==SP)) {
2624 match(SP);
2625 }
2626 else {
2627 break _loop299;
2628 }
2629
2630 } while (true);
2631 }
2632 anyUserPermission();
2633 {
2634 _loop301:
2635 do {
2636 if ((LA(1)==SP)) {
2637 match(SP);
2638 }
2639 else {
2640 break _loop301;
2641 }
2642
2643 } while (true);
2644 }
2645 {
2646 _loop307:
2647 do {
2648 if ((LA(1)==SEP)) {
2649 match(SEP);
2650 {
2651 _loop304:
2652 do {
2653 if ((LA(1)==SP)) {
2654 match(SP);
2655 }
2656 else {
2657 break _loop304;
2658 }
2659
2660 } while (true);
2661 }
2662 anyUserPermission();
2663 {
2664 _loop306:
2665 do {
2666 if ((LA(1)==SP)) {
2667 match(SP);
2668 }
2669 else {
2670 break _loop306;
2671 }
2672
2673 } while (true);
2674 }
2675 }
2676 else {
2677 break _loop307;
2678 }
2679
2680 } while (true);
2681 }
2682 match(CLOSE_CURLY);
2683 }
2684
2685 public final void anyUserPermission() throws RecognitionException, TokenStreamException {
2686
2687
2688 switch ( LA(1)) {
2689 case ID_precedence:
2690 {
2691 precedence();
2692 break;
2693 }
2694 case ID_protectedItems:
2695 {
2696 protectedItems();
2697 break;
2698 }
2699 case ID_grantsAndDenials:
2700 {
2701 grantsAndDenials();
2702 break;
2703 }
2704 default:
2705 {
2706 throw new NoViableAltException(LT(1), getFilename());
2707 }
2708 }
2709 }
2710
2711 public final void subtreeSpecificationComponent() throws RecognitionException, TokenStreamException {
2712
2713
2714 switch ( LA(1)) {
2715 case ID_base:
2716 {
2717 ss_base();
2718 break;
2719 }
2720 case ID_specificExclusions:
2721 {
2722 ss_specificExclusions();
2723 break;
2724 }
2725 case ID_minimum:
2726 {
2727 ss_minimum();
2728 break;
2729 }
2730 case ID_maximum:
2731 {
2732 ss_maximum();
2733 break;
2734 }
2735 default:
2736 {
2737 throw new NoViableAltException(LT(1), getFilename());
2738 }
2739 }
2740 }
2741
2742 public final void ss_base() throws RecognitionException, TokenStreamException {
2743
2744
2745 match(ID_base);
2746 {
2747 int _cnt324=0;
2748 _loop324:
2749 do {
2750 if ((LA(1)==SP)) {
2751 match(SP);
2752 }
2753 else {
2754 if ( _cnt324>=1 ) { break _loop324; } else {throw new NoViableAltException(LT(1), getFilename());}
2755 }
2756
2757 _cnt324++;
2758 } while (true);
2759 }
2760 distinguishedName();
2761 }
2762
2763 public final void ss_specificExclusions() throws RecognitionException, TokenStreamException {
2764
2765
2766 match(ID_specificExclusions);
2767 {
2768 int _cnt327=0;
2769 _loop327:
2770 do {
2771 if ((LA(1)==SP)) {
2772 match(SP);
2773 }
2774 else {
2775 if ( _cnt327>=1 ) { break _loop327; } else {throw new NoViableAltException(LT(1), getFilename());}
2776 }
2777
2778 _cnt327++;
2779 } while (true);
2780 }
2781 specificExclusions();
2782 }
2783
2784 public final void ss_minimum() throws RecognitionException, TokenStreamException {
2785
2786
2787 match(ID_minimum);
2788 {
2789 int _cnt353=0;
2790 _loop353:
2791 do {
2792 if ((LA(1)==SP)) {
2793 match(SP);
2794 }
2795 else {
2796 if ( _cnt353>=1 ) { break _loop353; } else {throw new NoViableAltException(LT(1), getFilename());}
2797 }
2798
2799 _cnt353++;
2800 } while (true);
2801 }
2802 baseDistance();
2803 }
2804
2805 public final void ss_maximum() throws RecognitionException, TokenStreamException {
2806
2807
2808 match(ID_maximum);
2809 {
2810 int _cnt356=0;
2811 _loop356:
2812 do {
2813 if ((LA(1)==SP)) {
2814 match(SP);
2815 }
2816 else {
2817 if ( _cnt356>=1 ) { break _loop356; } else {throw new NoViableAltException(LT(1), getFilename());}
2818 }
2819
2820 _cnt356++;
2821 } while (true);
2822 }
2823 baseDistance();
2824 }
2825
2826 public final void specificExclusions() throws RecognitionException, TokenStreamException {
2827
2828
2829 match(OPEN_CURLY);
2830 {
2831 _loop330:
2832 do {
2833 if ((LA(1)==SP)) {
2834 match(SP);
2835 }
2836 else {
2837 break _loop330;
2838 }
2839
2840 } while (true);
2841 }
2842 {
2843 switch ( LA(1)) {
2844 case ID_chopBefore:
2845 case ID_chopAfter:
2846 {
2847 specificExclusion();
2848 {
2849 _loop333:
2850 do {
2851 if ((LA(1)==SP)) {
2852 match(SP);
2853 }
2854 else {
2855 break _loop333;
2856 }
2857
2858 } while (true);
2859 }
2860 {
2861 _loop339:
2862 do {
2863 if ((LA(1)==SEP)) {
2864 match(SEP);
2865 {
2866 _loop336:
2867 do {
2868 if ((LA(1)==SP)) {
2869 match(SP);
2870 }
2871 else {
2872 break _loop336;
2873 }
2874
2875 } while (true);
2876 }
2877 specificExclusion();
2878 {
2879 _loop338:
2880 do {
2881 if ((LA(1)==SP)) {
2882 match(SP);
2883 }
2884 else {
2885 break _loop338;
2886 }
2887
2888 } while (true);
2889 }
2890 }
2891 else {
2892 break _loop339;
2893 }
2894
2895 } while (true);
2896 }
2897 break;
2898 }
2899 case CLOSE_CURLY:
2900 {
2901 break;
2902 }
2903 default:
2904 {
2905 throw new NoViableAltException(LT(1), getFilename());
2906 }
2907 }
2908 }
2909 match(CLOSE_CURLY);
2910 }
2911
2912 public final void specificExclusion() throws RecognitionException, TokenStreamException {
2913
2914
2915 switch ( LA(1)) {
2916 case ID_chopBefore:
2917 {
2918 chopBefore();
2919 break;
2920 }
2921 case ID_chopAfter:
2922 {
2923 chopAfter();
2924 break;
2925 }
2926 default:
2927 {
2928 throw new NoViableAltException(LT(1), getFilename());
2929 }
2930 }
2931 }
2932
2933 public final void chopBefore() throws RecognitionException, TokenStreamException {
2934
2935
2936 match(ID_chopBefore);
2937 {
2938 _loop343:
2939 do {
2940 if ((LA(1)==SP)) {
2941 match(SP);
2942 }
2943 else {
2944 break _loop343;
2945 }
2946
2947 } while (true);
2948 }
2949 match(COLON);
2950 {
2951 _loop345:
2952 do {
2953 if ((LA(1)==SP)) {
2954 match(SP);
2955 }
2956 else {
2957 break _loop345;
2958 }
2959
2960 } while (true);
2961 }
2962 distinguishedName();
2963 }
2964
2965 public final void chopAfter() throws RecognitionException, TokenStreamException {
2966
2967
2968 match(ID_chopAfter);
2969 {
2970 _loop348:
2971 do {
2972 if ((LA(1)==SP)) {
2973 match(SP);
2974 }
2975 else {
2976 break _loop348;
2977 }
2978
2979 } while (true);
2980 }
2981 match(COLON);
2982 {
2983 _loop350:
2984 do {
2985 if ((LA(1)==SP)) {
2986 match(SP);
2987 }
2988 else {
2989 break _loop350;
2990 }
2991
2992 } while (true);
2993 }
2994 distinguishedName();
2995 }
2996
2997 public final void baseDistance() throws RecognitionException, TokenStreamException {
2998
2999
3000 match(INTEGER);
3001 }
3002
3003 public final void item() throws RecognitionException, TokenStreamException {
3004
3005
3006 match(ID_item);
3007 {
3008 _loop364:
3009 do {
3010 if ((LA(1)==SP)) {
3011 match(SP);
3012 }
3013 else {
3014 break _loop364;
3015 }
3016
3017 } while (true);
3018 }
3019 match(COLON);
3020 {
3021 _loop366:
3022 do {
3023 if ((LA(1)==SP)) {
3024 match(SP);
3025 }
3026 else {
3027 break _loop366;
3028 }
3029
3030 } while (true);
3031 }
3032 oid();
3033 }
3034
3035 public final void and() throws RecognitionException, TokenStreamException {
3036
3037
3038 match(ID_and);
3039 {
3040 _loop369:
3041 do {
3042 if ((LA(1)==SP)) {
3043 match(SP);
3044 }
3045 else {
3046 break _loop369;
3047 }
3048
3049 } while (true);
3050 }
3051 match(COLON);
3052 {
3053 _loop371:
3054 do {
3055 if ((LA(1)==SP)) {
3056 match(SP);
3057 }
3058 else {
3059 break _loop371;
3060 }
3061
3062 } while (true);
3063 }
3064 refinements();
3065 }
3066
3067 public final void or() throws RecognitionException, TokenStreamException {
3068
3069
3070 match(ID_or);
3071 {
3072 _loop374:
3073 do {
3074 if ((LA(1)==SP)) {
3075 match(SP);
3076 }
3077 else {
3078 break _loop374;
3079 }
3080
3081 } while (true);
3082 }
3083 match(COLON);
3084 {
3085 _loop376:
3086 do {
3087 if ((LA(1)==SP)) {
3088 match(SP);
3089 }
3090 else {
3091 break _loop376;
3092 }
3093
3094 } while (true);
3095 }
3096 refinements();
3097 }
3098
3099 public final void not() throws RecognitionException, TokenStreamException {
3100
3101
3102 match(ID_not);
3103 {
3104 _loop379:
3105 do {
3106 if ((LA(1)==SP)) {
3107 match(SP);
3108 }
3109 else {
3110 break _loop379;
3111 }
3112
3113 } while (true);
3114 }
3115 match(COLON);
3116 {
3117 _loop381:
3118 do {
3119 if ((LA(1)==SP)) {
3120 match(SP);
3121 }
3122 else {
3123 break _loop381;
3124 }
3125
3126 } while (true);
3127 }
3128 refinements();
3129 }
3130
3131 public final void refinements() throws RecognitionException, TokenStreamException {
3132
3133
3134 match(OPEN_CURLY);
3135 {
3136 _loop384:
3137 do {
3138 if ((LA(1)==SP)) {
3139 match(SP);
3140 }
3141 else {
3142 break _loop384;
3143 }
3144
3145 } while (true);
3146 }
3147 {
3148 switch ( LA(1)) {
3149 case ID_item:
3150 case ID_and:
3151 case ID_or:
3152 case ID_not:
3153 {
3154 refinement();
3155 {
3156 _loop387:
3157 do {
3158 if ((LA(1)==SP)) {
3159 match(SP);
3160 }
3161 else {
3162 break _loop387;
3163 }
3164
3165 } while (true);
3166 }
3167 {
3168 _loop393:
3169 do {
3170 if ((LA(1)==SEP)) {
3171 match(SEP);
3172 {
3173 _loop390:
3174 do {
3175 if ((LA(1)==SP)) {
3176 match(SP);
3177 }
3178 else {
3179 break _loop390;
3180 }
3181
3182 } while (true);
3183 }
3184 refinement();
3185 {
3186 _loop392:
3187 do {
3188 if ((LA(1)==SP)) {
3189 match(SP);
3190 }
3191 else {
3192 break _loop392;
3193 }
3194
3195 } while (true);
3196 }
3197 }
3198 else {
3199 break _loop393;
3200 }
3201
3202 } while (true);
3203 }
3204 break;
3205 }
3206 case CLOSE_CURLY:
3207 {
3208 break;
3209 }
3210 default:
3211 {
3212 throw new NoViableAltException(LT(1), getFilename());
3213 }
3214 }
3215 }
3216 match(CLOSE_CURLY);
3217 }
3218
3219
3220 public static final String[] _tokenNames = {
3221 "<0>",
3222 "EOF",
3223 "<2>",
3224 "NULL_TREE_LOOKAHEAD",
3225 "ATTRIBUTE_VALUE_CANDIDATE",
3226 "RANGE_OF_VALUES_CANDIDATE",
3227 "SP",
3228 "OPEN_CURLY",
3229 "SEP",
3230 "CLOSE_CURLY",
3231 "\"identificationTag\"",
3232 "SAFEUTF8STRING",
3233 "\"precedence\"",
3234 "INTEGER",
3235 "\"authenticationLevel\"",
3236 "\"none\"",
3237 "\"simple\"",
3238 "\"strong\"",
3239 "\"itemOrUserFirst\"",
3240 "\"itemFirst\"",
3241 "COLON",
3242 "\"userFirst\"",
3243 "\"protectedItems\"",
3244 "\"entry\"",
3245 "\"allUserAttributeTypes\"",
3246 "\"attributeType\"",
3247 "\"allAttributeValues\"",
3248 "\"allUserAttributeTypesAndValues\"",
3249 "\"selfValue\"",
3250 "\"maxValueCount\"",
3251 "\"type\"",
3252 "\"maxCount\"",
3253 "\"maxImmSub\"",
3254 "\"restrictedBy\"",
3255 "\"valuesIn\"",
3256 "\"classes\"",
3257 "\"itemPermissions\"",
3258 "\"grantsAndDenials\"",
3259 "\"grantAdd\"",
3260 "\"denyAdd\"",
3261 "\"grantDiscloseOnError\"",
3262 "\"denyDiscloseOnError\"",
3263 "\"grantRead\"",
3264 "\"denyRead\"",
3265 "\"grantRemove\"",
3266 "\"denyRemove\"",
3267 "\"grantBrowse\"",
3268 "\"denyBrowse\"",
3269 "\"grantExport\"",
3270 "\"denyExport\"",
3271 "\"grantImport\"",
3272 "\"denyImport\"",
3273 "\"grantModify\"",
3274 "\"denyModify\"",
3275 "\"grantRename\"",
3276 "\"denyRename\"",
3277 "\"grantReturnDN\"",
3278 "\"denyReturnDN\"",
3279 "\"grantCompare\"",
3280 "\"denyCompare\"",
3281 "\"grantFilterMatch\"",
3282 "\"denyFilterMatch\"",
3283 "\"grantInvoke\"",
3284 "\"denyInvoke\"",
3285 "\"userClasses\"",
3286 "\"allUsers\"",
3287 "\"thisEntry\"",
3288 "\"parentOfEntry\"",
3289 "\"name\"",
3290 "\"userGroup\"",
3291 "\"subtree\"",
3292 "\"userPermissions\"",
3293 "\"base\"",
3294 "\"specificExclusions\"",
3295 "\"chopBefore\"",
3296 "\"chopAfter\"",
3297 "\"minimum\"",
3298 "\"maximum\"",
3299 "DESCR",
3300 "NUMERICOID",
3301 "\"item\"",
3302 "\"and\"",
3303 "\"or\"",
3304 "\"not\"",
3305 "\"FALSE\"",
3306 "\"TRUE\"",
3307 "\"level\"",
3308 "\"basicLevels\"",
3309 "\"localQualifier\"",
3310 "\"signed\"",
3311 "\"rangeOfValues\"",
3312 "\"specificationFilter\"",
3313 "SAFEUTF8CHAR",
3314 "DIGIT",
3315 "LDIGIT",
3316 "ALPHA",
3317 "HYPHEN",
3318 "DOT",
3319 "INTEGER_OR_NUMERICOID",
3320 "FILTER",
3321 "FILTER_VALUE"
3322 };
3323
3324
3325 }