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