001 // $ANTLR 2.7.4: "ACIItemChecker.g" -> "AntlrACIItemChecker.java"$
002
003 /*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements. See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership. The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License. You may obtain a copy of the License at
011 *
012 * http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied. See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 *
021 */
022
023
024 package org.apache.directory.shared.ldap.aci;
025
026
027 import org.apache.directory.shared.ldap.name.NameComponentNormalizer;
028
029 import antlr.TokenBuffer;
030 import antlr.TokenStreamException;
031 import antlr.TokenStreamIOException;
032 import antlr.ANTLRException;
033 import antlr.LLkParser;
034 import antlr.Token;
035 import antlr.TokenStream;
036 import antlr.RecognitionException;
037 import antlr.NoViableAltException;
038 import antlr.MismatchedTokenException;
039 import antlr.SemanticException;
040 import antlr.ParserSharedInputState;
041 import antlr.collections.impl.BitSet;
042
043 /**
044 * The antlr generated ACIItem checker.
045 *
046 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
047 * @version $Rev$
048 */
049 public class AntlrACIItemChecker extends antlr.LLkParser implements AntlrACIItemCheckerTokenTypes
050 {
051
052 NameComponentNormalizer normalizer;
053
054 /**
055 * Creates a (normalizing) subordinate DnParser for parsing Names.
056 * This method MUST be called for each instance while we cannot do
057 * constructor overloading for this class.
058 *
059 * @return the DnParser to be used for parsing Names
060 */
061 public void init()
062 {
063 }
064
065 /**
066 * Sets the NameComponentNormalizer for this parser's dnParser.
067 */
068 public void setNormalizer(NameComponentNormalizer normalizer)
069 {
070 this.normalizer = normalizer;
071 }
072
073 protected AntlrACIItemChecker(TokenBuffer tokenBuf, int k) {
074 super(tokenBuf,k);
075 tokenNames = _tokenNames;
076 }
077
078 public AntlrACIItemChecker(TokenBuffer tokenBuf) {
079 this(tokenBuf,1);
080 }
081
082 protected AntlrACIItemChecker(TokenStream lexer, int k) {
083 super(lexer,k);
084 tokenNames = _tokenNames;
085 }
086
087 public AntlrACIItemChecker(TokenStream lexer) {
088 this(lexer,1);
089 }
090
091 public AntlrACIItemChecker(ParserSharedInputState state) {
092 super(state,1);
093 tokenNames = _tokenNames;
094 }
095
096 public final void wrapperEntryPoint() throws RecognitionException, TokenStreamException {
097
098
099 {
100 _loop461:
101 do {
102 if ((LA(1)==SP)) {
103 match(SP);
104 }
105 else {
106 break _loop461;
107 }
108
109 } while (true);
110 }
111 theACIItem();
112 {
113 _loop463:
114 do {
115 if ((LA(1)==SP)) {
116 match(SP);
117 }
118 else {
119 break _loop463;
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 _loop466:
133 do {
134 if ((LA(1)==SP)) {
135 match(SP);
136 }
137 else {
138 break _loop466;
139 }
140
141 } while (true);
142 }
143 mainACIItemComponent();
144 {
145 _loop468:
146 do {
147 if ((LA(1)==SP)) {
148 match(SP);
149 }
150 else {
151 break _loop468;
152 }
153
154 } while (true);
155 }
156 {
157 _loop474:
158 do {
159 if ((LA(1)==SEP)) {
160 match(SEP);
161 {
162 _loop471:
163 do {
164 if ((LA(1)==SP)) {
165 match(SP);
166 }
167 else {
168 break _loop471;
169 }
170
171 } while (true);
172 }
173 mainACIItemComponent();
174 {
175 _loop473:
176 do {
177 if ((LA(1)==SP)) {
178 match(SP);
179 }
180 else {
181 break _loop473;
182 }
183
184 } while (true);
185 }
186 }
187 else {
188 break _loop474;
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 _cnt478=0;
233 _loop478:
234 do {
235 if ((LA(1)==SP)) {
236 match(SP);
237 }
238 else {
239 if ( _cnt478>=1 ) { break _loop478; } else {throw new NoViableAltException(LT(1), getFilename());}
240 }
241
242 _cnt478++;
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 _cnt485=0;
260 _loop485:
261 do {
262 if ((LA(1)==SP)) {
263 match(SP);
264 }
265 else {
266 if ( _cnt485>=1 ) { break _loop485; } else {throw new NoViableAltException(LT(1), getFilename());}
267 }
268
269 _cnt485++;
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 _cnt489=0;
281 _loop489:
282 do {
283 if ((LA(1)==SP)) {
284 match(SP);
285 }
286 else {
287 if ( _cnt489>=1 ) { break _loop489; } else {throw new NoViableAltException(LT(1), getFilename());}
288 }
289
290 _cnt489++;
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 _cnt482=0;
302 _loop482:
303 do {
304 if ((LA(1)==SP)) {
305 match(SP);
306 }
307 else {
308 if ( _cnt482>=1 ) { break _loop482; } else {throw new NoViableAltException(LT(1), getFilename());}
309 }
310
311 _cnt482++;
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 _loop493:
370 do {
371 if ((LA(1)==SP)) {
372 match(SP);
373 }
374 else {
375 break _loop493;
376 }
377
378 } while (true);
379 }
380 match(COLON);
381 {
382 _loop495:
383 do {
384 if ((LA(1)==SP)) {
385 match(SP);
386 }
387 else {
388 break _loop495;
389 }
390
391 } while (true);
392 }
393 match(OPEN_CURLY);
394 {
395 _loop497:
396 do {
397 if ((LA(1)==SP)) {
398 match(SP);
399 }
400 else {
401 break _loop497;
402 }
403
404 } while (true);
405 }
406 {
407 switch ( LA(1)) {
408 case ID_protectedItems:
409 {
410 protectedItems();
411 {
412 _loop500:
413 do {
414 if ((LA(1)==SP)) {
415 match(SP);
416 }
417 else {
418 break _loop500;
419 }
420
421 } while (true);
422 }
423 match(SEP);
424 {
425 _loop502:
426 do {
427 if ((LA(1)==SP)) {
428 match(SP);
429 }
430 else {
431 break _loop502;
432 }
433
434 } while (true);
435 }
436 itemPermissions();
437 break;
438 }
439 case ID_itemPermissions:
440 {
441 itemPermissions();
442 {
443 _loop504:
444 do {
445 if ((LA(1)==SP)) {
446 match(SP);
447 }
448 else {
449 break _loop504;
450 }
451
452 } while (true);
453 }
454 match(SEP);
455 {
456 _loop506:
457 do {
458 if ((LA(1)==SP)) {
459 match(SP);
460 }
461 else {
462 break _loop506;
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 _loop508:
478 do {
479 if ((LA(1)==SP)) {
480 match(SP);
481 }
482 else {
483 break _loop508;
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 _loop511:
497 do {
498 if ((LA(1)==SP)) {
499 match(SP);
500 }
501 else {
502 break _loop511;
503 }
504
505 } while (true);
506 }
507 match(COLON);
508 {
509 _loop513:
510 do {
511 if ((LA(1)==SP)) {
512 match(SP);
513 }
514 else {
515 break _loop513;
516 }
517
518 } while (true);
519 }
520 match(OPEN_CURLY);
521 {
522 _loop515:
523 do {
524 if ((LA(1)==SP)) {
525 match(SP);
526 }
527 else {
528 break _loop515;
529 }
530
531 } while (true);
532 }
533 {
534 switch ( LA(1)) {
535 case ID_userClasses:
536 {
537 userClasses();
538 {
539 _loop518:
540 do {
541 if ((LA(1)==SP)) {
542 match(SP);
543 }
544 else {
545 break _loop518;
546 }
547
548 } while (true);
549 }
550 match(SEP);
551 {
552 _loop520:
553 do {
554 if ((LA(1)==SP)) {
555 match(SP);
556 }
557 else {
558 break _loop520;
559 }
560
561 } while (true);
562 }
563 userPermissions();
564 break;
565 }
566 case ID_userPermissions:
567 {
568 userPermissions();
569 {
570 _loop522:
571 do {
572 if ((LA(1)==SP)) {
573 match(SP);
574 }
575 else {
576 break _loop522;
577 }
578
579 } while (true);
580 }
581 match(SEP);
582 {
583 _loop524:
584 do {
585 if ((LA(1)==SP)) {
586 match(SP);
587 }
588 else {
589 break _loop524;
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 _loop526:
605 do {
606 if ((LA(1)==SP)) {
607 match(SP);
608 }
609 else {
610 break _loop526;
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 _loop529:
624 do {
625 if ((LA(1)==SP)) {
626 match(SP);
627 }
628 else {
629 break _loop529;
630 }
631
632 } while (true);
633 }
634 match(OPEN_CURLY);
635 {
636 _loop531:
637 do {
638 if ((LA(1)==SP)) {
639 match(SP);
640 }
641 else {
642 break _loop531;
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 _loop534:
665 do {
666 if ((LA(1)==SP)) {
667 match(SP);
668 }
669 else {
670 break _loop534;
671 }
672
673 } while (true);
674 }
675 {
676 _loop540:
677 do {
678 if ((LA(1)==SEP)) {
679 match(SEP);
680 {
681 _loop537:
682 do {
683 if ((LA(1)==SP)) {
684 match(SP);
685 }
686 else {
687 break _loop537;
688 }
689
690 } while (true);
691 }
692 protectedItem();
693 {
694 _loop539:
695 do {
696 if ((LA(1)==SP)) {
697 match(SP);
698 }
699 else {
700 break _loop539;
701 }
702
703 } while (true);
704 }
705 }
706 else {
707 break _loop540;
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 _cnt645=0;
733 _loop645:
734 do {
735 if ((LA(1)==SP)) {
736 match(SP);
737 }
738 else {
739 if ( _cnt645>=1 ) { break _loop645; } else {throw new NoViableAltException(LT(1), getFilename());}
740 }
741
742 _cnt645++;
743 } while (true);
744 }
745 match(OPEN_CURLY);
746 {
747 _loop647:
748 do {
749 if ((LA(1)==SP)) {
750 match(SP);
751 }
752 else {
753 break _loop647;
754 }
755
756 } while (true);
757 }
758 {
759 switch ( LA(1)) {
760 case OPEN_CURLY:
761 {
762 itemPermission();
763 {
764 _loop650:
765 do {
766 if ((LA(1)==SP)) {
767 match(SP);
768 }
769 else {
770 break _loop650;
771 }
772
773 } while (true);
774 }
775 {
776 _loop656:
777 do {
778 if ((LA(1)==SEP)) {
779 match(SEP);
780 {
781 _loop653:
782 do {
783 if ((LA(1)==SP)) {
784 match(SP);
785 }
786 else {
787 break _loop653;
788 }
789
790 } while (true);
791 }
792 itemPermission();
793 {
794 _loop655:
795 do {
796 if ((LA(1)==SP)) {
797 match(SP);
798 }
799 else {
800 break _loop655;
801 }
802
803 } while (true);
804 }
805 }
806 else {
807 break _loop656;
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 _cnt686=0;
833 _loop686:
834 do {
835 if ((LA(1)==SP)) {
836 match(SP);
837 }
838 else {
839 if ( _cnt686>=1 ) { break _loop686; } else {throw new NoViableAltException(LT(1), getFilename());}
840 }
841
842 _cnt686++;
843 } while (true);
844 }
845 match(OPEN_CURLY);
846 {
847 _loop688:
848 do {
849 if ((LA(1)==SP)) {
850 match(SP);
851 }
852 else {
853 break _loop688;
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 _loop691:
870 do {
871 if ((LA(1)==SP)) {
872 match(SP);
873 }
874 else {
875 break _loop691;
876 }
877
878 } while (true);
879 }
880 {
881 _loop697:
882 do {
883 if ((LA(1)==SEP)) {
884 match(SEP);
885 {
886 _loop694:
887 do {
888 if ((LA(1)==SP)) {
889 match(SP);
890 }
891 else {
892 break _loop694;
893 }
894
895 } while (true);
896 }
897 userClass();
898 {
899 _loop696:
900 do {
901 if ((LA(1)==SP)) {
902 match(SP);
903 }
904 else {
905 break _loop696;
906 }
907
908 } while (true);
909 }
910 }
911 else {
912 break _loop697;
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 _cnt743=0;
938 _loop743:
939 do {
940 if ((LA(1)==SP)) {
941 match(SP);
942 }
943 else {
944 if ( _cnt743>=1 ) { break _loop743; } else {throw new NoViableAltException(LT(1), getFilename());}
945 }
946
947 _cnt743++;
948 } while (true);
949 }
950 match(OPEN_CURLY);
951 {
952 _loop745:
953 do {
954 if ((LA(1)==SP)) {
955 match(SP);
956 }
957 else {
958 break _loop745;
959 }
960
961 } while (true);
962 }
963 {
964 switch ( LA(1)) {
965 case OPEN_CURLY:
966 {
967 userPermission();
968 {
969 _loop748:
970 do {
971 if ((LA(1)==SP)) {
972 match(SP);
973 }
974 else {
975 break _loop748;
976 }
977
978 } while (true);
979 }
980 {
981 _loop754:
982 do {
983 if ((LA(1)==SEP)) {
984 match(SEP);
985 {
986 _loop751:
987 do {
988 if ((LA(1)==SP)) {
989 match(SP);
990 }
991 else {
992 break _loop751;
993 }
994
995 } while (true);
996 }
997 userPermission();
998 {
999 _loop753:
1000 do {
1001 if ((LA(1)==SP)) {
1002 match(SP);
1003 }
1004 else {
1005 break _loop753;
1006 }
1007
1008 } while (true);
1009 }
1010 }
1011 else {
1012 break _loop754;
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 _cnt546=0;
1121 _loop546:
1122 do {
1123 if ((LA(1)==SP)) {
1124 match(SP);
1125 }
1126 else {
1127 if ( _cnt546>=1 ) { break _loop546; } else {throw new NoViableAltException(LT(1), getFilename());}
1128 }
1129
1130 _cnt546++;
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 _cnt549=0;
1142 _loop549:
1143 do {
1144 if ((LA(1)==SP)) {
1145 match(SP);
1146 }
1147 else {
1148 if ( _cnt549>=1 ) { break _loop549; } else {throw new NoViableAltException(LT(1), getFilename());}
1149 }
1150
1151 _cnt549++;
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 _cnt554=0;
1175 _loop554:
1176 do {
1177 if ((LA(1)==SP)) {
1178 match(SP);
1179 }
1180 else {
1181 if ( _cnt554>=1 ) { break _loop554; } else {throw new NoViableAltException(LT(1), getFilename());}
1182 }
1183
1184 _cnt554++;
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 _cnt558=0;
1202 _loop558:
1203 do {
1204 if ((LA(1)==SP)) {
1205 match(SP);
1206 }
1207 else {
1208 if ( _cnt558>=1 ) { break _loop558; } else {throw new NoViableAltException(LT(1), getFilename());}
1209 }
1210
1211 _cnt558++;
1212 } while (true);
1213 }
1214 match(OPEN_CURLY);
1215 {
1216 _loop560:
1217 do {
1218 if ((LA(1)==SP)) {
1219 match(SP);
1220 }
1221 else {
1222 break _loop560;
1223 }
1224
1225 } while (true);
1226 }
1227 aMaxValueCount();
1228 {
1229 _loop562:
1230 do {
1231 if ((LA(1)==SP)) {
1232 match(SP);
1233 }
1234 else {
1235 break _loop562;
1236 }
1237
1238 } while (true);
1239 }
1240 {
1241 _loop568:
1242 do {
1243 if ((LA(1)==SEP)) {
1244 match(SEP);
1245 {
1246 _loop565:
1247 do {
1248 if ((LA(1)==SP)) {
1249 match(SP);
1250 }
1251 else {
1252 break _loop565;
1253 }
1254
1255 } while (true);
1256 }
1257 aMaxValueCount();
1258 {
1259 _loop567:
1260 do {
1261 if ((LA(1)==SP)) {
1262 match(SP);
1263 }
1264 else {
1265 break _loop567;
1266 }
1267
1268 } while (true);
1269 }
1270 }
1271 else {
1272 break _loop568;
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 _cnt593=0;
1286 _loop593:
1287 do {
1288 if ((LA(1)==SP)) {
1289 match(SP);
1290 }
1291 else {
1292 if ( _cnt593>=1 ) { break _loop593; } else {throw new NoViableAltException(LT(1), getFilename());}
1293 }
1294
1295 _cnt593++;
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 _cnt596=0;
1307 _loop596:
1308 do {
1309 if ((LA(1)==SP)) {
1310 match(SP);
1311 }
1312 else {
1313 if ( _cnt596>=1 ) { break _loop596; } else {throw new NoViableAltException(LT(1), getFilename());}
1314 }
1315
1316 _cnt596++;
1317 } while (true);
1318 }
1319 match(OPEN_CURLY);
1320 {
1321 _loop598:
1322 do {
1323 if ((LA(1)==SP)) {
1324 match(SP);
1325 }
1326 else {
1327 break _loop598;
1328 }
1329
1330 } while (true);
1331 }
1332 restrictedValue();
1333 {
1334 _loop600:
1335 do {
1336 if ((LA(1)==SP)) {
1337 match(SP);
1338 }
1339 else {
1340 break _loop600;
1341 }
1342
1343 } while (true);
1344 }
1345 {
1346 _loop606:
1347 do {
1348 if ((LA(1)==SEP)) {
1349 match(SEP);
1350 {
1351 _loop603:
1352 do {
1353 if ((LA(1)==SP)) {
1354 match(SP);
1355 }
1356 else {
1357 break _loop603;
1358 }
1359
1360 } while (true);
1361 }
1362 restrictedValue();
1363 {
1364 _loop605:
1365 do {
1366 if ((LA(1)==SP)) {
1367 match(SP);
1368 }
1369 else {
1370 break _loop605;
1371 }
1372
1373 } while (true);
1374 }
1375 }
1376 else {
1377 break _loop606;
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 _cnt642=0;
1391 _loop642:
1392 do {
1393 if ((LA(1)==SP)) {
1394 match(SP);
1395 }
1396 else {
1397 if ( _cnt642>=1 ) { break _loop642; } else {throw new NoViableAltException(LT(1), getFilename());}
1398 }
1399
1400 _cnt642++;
1401 } while (true);
1402 }
1403 refinement();
1404 }
1405
1406 public final void attributeTypeSet() throws RecognitionException, TokenStreamException {
1407
1408
1409 match(OPEN_CURLY);
1410 {
1411 _loop631:
1412 do {
1413 if ((LA(1)==SP)) {
1414 match(SP);
1415 }
1416 else {
1417 break _loop631;
1418 }
1419
1420 } while (true);
1421 }
1422 oid();
1423 {
1424 _loop633:
1425 do {
1426 if ((LA(1)==SP)) {
1427 match(SP);
1428 }
1429 else {
1430 break _loop633;
1431 }
1432
1433 } while (true);
1434 }
1435 {
1436 _loop639:
1437 do {
1438 if ((LA(1)==SEP)) {
1439 match(SEP);
1440 {
1441 _loop636:
1442 do {
1443 if ((LA(1)==SP)) {
1444 match(SP);
1445 }
1446 else {
1447 break _loop636;
1448 }
1449
1450 } while (true);
1451 }
1452 oid();
1453 {
1454 _loop638:
1455 do {
1456 if ((LA(1)==SP)) {
1457 match(SP);
1458 }
1459 else {
1460 break _loop638;
1461 }
1462
1463 } while (true);
1464 }
1465 }
1466 else {
1467 break _loop639;
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 _loop571:
1481 do {
1482 if ((LA(1)==SP)) {
1483 match(SP);
1484 }
1485 else {
1486 break _loop571;
1487 }
1488
1489 } while (true);
1490 }
1491 {
1492 switch ( LA(1)) {
1493 case ID_type:
1494 {
1495 match(ID_type);
1496 {
1497 int _cnt574=0;
1498 _loop574:
1499 do {
1500 if ((LA(1)==SP)) {
1501 match(SP);
1502 }
1503 else {
1504 if ( _cnt574>=1 ) { break _loop574; } else {throw new NoViableAltException(LT(1), getFilename());}
1505 }
1506
1507 _cnt574++;
1508 } while (true);
1509 }
1510 oid();
1511 {
1512 _loop576:
1513 do {
1514 if ((LA(1)==SP)) {
1515 match(SP);
1516 }
1517 else {
1518 break _loop576;
1519 }
1520
1521 } while (true);
1522 }
1523 match(SEP);
1524 {
1525 _loop578:
1526 do {
1527 if ((LA(1)==SP)) {
1528 match(SP);
1529 }
1530 else {
1531 break _loop578;
1532 }
1533
1534 } while (true);
1535 }
1536 match(ID_maxCount);
1537 {
1538 int _cnt580=0;
1539 _loop580:
1540 do {
1541 if ((LA(1)==SP)) {
1542 match(SP);
1543 }
1544 else {
1545 if ( _cnt580>=1 ) { break _loop580; } else {throw new NoViableAltException(LT(1), getFilename());}
1546 }
1547
1548 _cnt580++;
1549 } while (true);
1550 }
1551 match(INTEGER);
1552 break;
1553 }
1554 case ID_maxCount:
1555 {
1556 match(ID_maxCount);
1557 {
1558 int _cnt582=0;
1559 _loop582:
1560 do {
1561 if ((LA(1)==SP)) {
1562 match(SP);
1563 }
1564 else {
1565 if ( _cnt582>=1 ) { break _loop582; } else {throw new NoViableAltException(LT(1), getFilename());}
1566 }
1567
1568 _cnt582++;
1569 } while (true);
1570 }
1571 match(INTEGER);
1572 {
1573 _loop584:
1574 do {
1575 if ((LA(1)==SP)) {
1576 match(SP);
1577 }
1578 else {
1579 break _loop584;
1580 }
1581
1582 } while (true);
1583 }
1584 match(SEP);
1585 {
1586 _loop586:
1587 do {
1588 if ((LA(1)==SP)) {
1589 match(SP);
1590 }
1591 else {
1592 break _loop586;
1593 }
1594
1595 } while (true);
1596 }
1597 match(ID_type);
1598 {
1599 int _cnt588=0;
1600 _loop588:
1601 do {
1602 if ((LA(1)==SP)) {
1603 match(SP);
1604 }
1605 else {
1606 if ( _cnt588>=1 ) { break _loop588; } else {throw new NoViableAltException(LT(1), getFilename());}
1607 }
1608
1609 _cnt588++;
1610 } while (true);
1611 }
1612 oid();
1613 break;
1614 }
1615 default:
1616 {
1617 throw new NoViableAltException(LT(1), getFilename());
1618 }
1619 }
1620 }
1621 {
1622 _loop590:
1623 do {
1624 if ((LA(1)==SP)) {
1625 match(SP);
1626 }
1627 else {
1628 break _loop590;
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 _loop609:
1665 do {
1666 if ((LA(1)==SP)) {
1667 match(SP);
1668 }
1669 else {
1670 break _loop609;
1671 }
1672
1673 } while (true);
1674 }
1675 {
1676 switch ( LA(1)) {
1677 case ID_type:
1678 {
1679 match(ID_type);
1680 {
1681 int _cnt612=0;
1682 _loop612:
1683 do {
1684 if ((LA(1)==SP)) {
1685 match(SP);
1686 }
1687 else {
1688 if ( _cnt612>=1 ) { break _loop612; } else {throw new NoViableAltException(LT(1), getFilename());}
1689 }
1690
1691 _cnt612++;
1692 } while (true);
1693 }
1694 oid();
1695 {
1696 _loop614:
1697 do {
1698 if ((LA(1)==SP)) {
1699 match(SP);
1700 }
1701 else {
1702 break _loop614;
1703 }
1704
1705 } while (true);
1706 }
1707 match(SEP);
1708 {
1709 _loop616:
1710 do {
1711 if ((LA(1)==SP)) {
1712 match(SP);
1713 }
1714 else {
1715 break _loop616;
1716 }
1717
1718 } while (true);
1719 }
1720 match(ID_valuesIn);
1721 {
1722 int _cnt618=0;
1723 _loop618:
1724 do {
1725 if ((LA(1)==SP)) {
1726 match(SP);
1727 }
1728 else {
1729 if ( _cnt618>=1 ) { break _loop618; } else {throw new NoViableAltException(LT(1), getFilename());}
1730 }
1731
1732 _cnt618++;
1733 } while (true);
1734 }
1735 oid();
1736 break;
1737 }
1738 case ID_valuesIn:
1739 {
1740 match(ID_valuesIn);
1741 {
1742 int _cnt620=0;
1743 _loop620:
1744 do {
1745 if ((LA(1)==SP)) {
1746 match(SP);
1747 }
1748 else {
1749 if ( _cnt620>=1 ) { break _loop620; } else {throw new NoViableAltException(LT(1), getFilename());}
1750 }
1751
1752 _cnt620++;
1753 } while (true);
1754 }
1755 oid();
1756 {
1757 _loop622:
1758 do {
1759 if ((LA(1)==SP)) {
1760 match(SP);
1761 }
1762 else {
1763 break _loop622;
1764 }
1765
1766 } while (true);
1767 }
1768 match(SEP);
1769 {
1770 _loop624:
1771 do {
1772 if ((LA(1)==SP)) {
1773 match(SP);
1774 }
1775 else {
1776 break _loop624;
1777 }
1778
1779 } while (true);
1780 }
1781 match(ID_type);
1782 {
1783 int _cnt626=0;
1784 _loop626:
1785 do {
1786 if ((LA(1)==SP)) {
1787 match(SP);
1788 }
1789 else {
1790 if ( _cnt626>=1 ) { break _loop626; } else {throw new NoViableAltException(LT(1), getFilename());}
1791 }
1792
1793 _cnt626++;
1794 } while (true);
1795 }
1796 oid();
1797 break;
1798 }
1799 default:
1800 {
1801 throw new NoViableAltException(LT(1), getFilename());
1802 }
1803 }
1804 }
1805 {
1806 _loop628:
1807 do {
1808 if ((LA(1)==SP)) {
1809 match(SP);
1810 }
1811 else {
1812 break _loop628;
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 _loop659:
1857 do {
1858 if ((LA(1)==SP)) {
1859 match(SP);
1860 }
1861 else {
1862 break _loop659;
1863 }
1864
1865 } while (true);
1866 }
1867 anyItemPermission();
1868 {
1869 _loop661:
1870 do {
1871 if ((LA(1)==SP)) {
1872 match(SP);
1873 }
1874 else {
1875 break _loop661;
1876 }
1877
1878 } while (true);
1879 }
1880 {
1881 _loop667:
1882 do {
1883 if ((LA(1)==SEP)) {
1884 match(SEP);
1885 {
1886 _loop664:
1887 do {
1888 if ((LA(1)==SP)) {
1889 match(SP);
1890 }
1891 else {
1892 break _loop664;
1893 }
1894
1895 } while (true);
1896 }
1897 anyItemPermission();
1898 {
1899 _loop666:
1900 do {
1901 if ((LA(1)==SP)) {
1902 match(SP);
1903 }
1904 else {
1905 break _loop666;
1906 }
1907
1908 } while (true);
1909 }
1910 }
1911 else {
1912 break _loop667;
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 _cnt671=0;
1952 _loop671:
1953 do {
1954 if ((LA(1)==SP)) {
1955 match(SP);
1956 }
1957 else {
1958 if ( _cnt671>=1 ) { break _loop671; } else {throw new NoViableAltException(LT(1), getFilename());}
1959 }
1960
1961 _cnt671++;
1962 } while (true);
1963 }
1964 match(OPEN_CURLY);
1965 {
1966 _loop673:
1967 do {
1968 if ((LA(1)==SP)) {
1969 match(SP);
1970 }
1971 else {
1972 break _loop673;
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 _loop676:
2009 do {
2010 if ((LA(1)==SP)) {
2011 match(SP);
2012 }
2013 else {
2014 break _loop676;
2015 }
2016
2017 } while (true);
2018 }
2019 {
2020 _loop682:
2021 do {
2022 if ((LA(1)==SEP)) {
2023 match(SEP);
2024 {
2025 _loop679:
2026 do {
2027 if ((LA(1)==SP)) {
2028 match(SP);
2029 }
2030 else {
2031 break _loop679;
2032 }
2033
2034 } while (true);
2035 }
2036 grantAndDenial();
2037 {
2038 _loop681:
2039 do {
2040 if ((LA(1)==SP)) {
2041 match(SP);
2042 }
2043 else {
2044 break _loop681;
2045 }
2046
2047 } while (true);
2048 }
2049 }
2050 else {
2051 break _loop682;
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 _cnt704=0;
2277 _loop704:
2278 do {
2279 if ((LA(1)==SP)) {
2280 match(SP);
2281 }
2282 else {
2283 if ( _cnt704>=1 ) { break _loop704; } else {throw new NoViableAltException(LT(1), getFilename());}
2284 }
2285
2286 _cnt704++;
2287 } while (true);
2288 }
2289 match(OPEN_CURLY);
2290 {
2291 _loop706:
2292 do {
2293 if ((LA(1)==SP)) {
2294 match(SP);
2295 }
2296 else {
2297 break _loop706;
2298 }
2299
2300 } while (true);
2301 }
2302 distinguishedName();
2303 {
2304 _loop708:
2305 do {
2306 if ((LA(1)==SP)) {
2307 match(SP);
2308 }
2309 else {
2310 break _loop708;
2311 }
2312
2313 } while (true);
2314 }
2315 {
2316 _loop714:
2317 do {
2318 if ((LA(1)==SEP)) {
2319 match(SEP);
2320 {
2321 _loop711:
2322 do {
2323 if ((LA(1)==SP)) {
2324 match(SP);
2325 }
2326 else {
2327 break _loop711;
2328 }
2329
2330 } while (true);
2331 }
2332 distinguishedName();
2333 {
2334 _loop713:
2335 do {
2336 if ((LA(1)==SP)) {
2337 match(SP);
2338 }
2339 else {
2340 break _loop713;
2341 }
2342
2343 } while (true);
2344 }
2345 }
2346 else {
2347 break _loop714;
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 _cnt717=0;
2361 _loop717:
2362 do {
2363 if ((LA(1)==SP)) {
2364 match(SP);
2365 }
2366 else {
2367 if ( _cnt717>=1 ) { break _loop717; } else {throw new NoViableAltException(LT(1), getFilename());}
2368 }
2369
2370 _cnt717++;
2371 } while (true);
2372 }
2373 match(OPEN_CURLY);
2374 {
2375 _loop719:
2376 do {
2377 if ((LA(1)==SP)) {
2378 match(SP);
2379 }
2380 else {
2381 break _loop719;
2382 }
2383
2384 } while (true);
2385 }
2386 distinguishedName();
2387 {
2388 _loop721:
2389 do {
2390 if ((LA(1)==SP)) {
2391 match(SP);
2392 }
2393 else {
2394 break _loop721;
2395 }
2396
2397 } while (true);
2398 }
2399 {
2400 _loop727:
2401 do {
2402 if ((LA(1)==SEP)) {
2403 match(SEP);
2404 {
2405 _loop724:
2406 do {
2407 if ((LA(1)==SP)) {
2408 match(SP);
2409 }
2410 else {
2411 break _loop724;
2412 }
2413
2414 } while (true);
2415 }
2416 distinguishedName();
2417 {
2418 _loop726:
2419 do {
2420 if ((LA(1)==SP)) {
2421 match(SP);
2422 }
2423 else {
2424 break _loop726;
2425 }
2426
2427 } while (true);
2428 }
2429 }
2430 else {
2431 break _loop727;
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 _cnt730=0;
2445 _loop730:
2446 do {
2447 if ((LA(1)==SP)) {
2448 match(SP);
2449 }
2450 else {
2451 if ( _cnt730>=1 ) { break _loop730; } else {throw new NoViableAltException(LT(1), getFilename());}
2452 }
2453
2454 _cnt730++;
2455 } while (true);
2456 }
2457 match(OPEN_CURLY);
2458 {
2459 _loop732:
2460 do {
2461 if ((LA(1)==SP)) {
2462 match(SP);
2463 }
2464 else {
2465 break _loop732;
2466 }
2467
2468 } while (true);
2469 }
2470 subtreeSpecification();
2471 {
2472 _loop734:
2473 do {
2474 if ((LA(1)==SP)) {
2475 match(SP);
2476 }
2477 else {
2478 break _loop734;
2479 }
2480
2481 } while (true);
2482 }
2483 {
2484 _loop740:
2485 do {
2486 if ((LA(1)==SEP)) {
2487 match(SEP);
2488 {
2489 _loop737:
2490 do {
2491 if ((LA(1)==SP)) {
2492 match(SP);
2493 }
2494 else {
2495 break _loop737;
2496 }
2497
2498 } while (true);
2499 }
2500 subtreeSpecification();
2501 {
2502 _loop739:
2503 do {
2504 if ((LA(1)==SP)) {
2505 match(SP);
2506 }
2507 else {
2508 break _loop739;
2509 }
2510
2511 } while (true);
2512 }
2513 }
2514 else {
2515 break _loop740;
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 _loop769:
2535 do {
2536 if ((LA(1)==SP)) {
2537 match(SP);
2538 }
2539 else {
2540 break _loop769;
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 _loop772:
2555 do {
2556 if ((LA(1)==SP)) {
2557 match(SP);
2558 }
2559 else {
2560 break _loop772;
2561 }
2562
2563 } while (true);
2564 }
2565 {
2566 _loop778:
2567 do {
2568 if ((LA(1)==SEP)) {
2569 match(SEP);
2570 {
2571 _loop775:
2572 do {
2573 if ((LA(1)==SP)) {
2574 match(SP);
2575 }
2576 else {
2577 break _loop775;
2578 }
2579
2580 } while (true);
2581 }
2582 subtreeSpecificationComponent();
2583 {
2584 _loop777:
2585 do {
2586 if ((LA(1)==SP)) {
2587 match(SP);
2588 }
2589 else {
2590 break _loop777;
2591 }
2592
2593 } while (true);
2594 }
2595 }
2596 else {
2597 break _loop778;
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 _loop757:
2623 do {
2624 if ((LA(1)==SP)) {
2625 match(SP);
2626 }
2627 else {
2628 break _loop757;
2629 }
2630
2631 } while (true);
2632 }
2633 anyUserPermission();
2634 {
2635 _loop759:
2636 do {
2637 if ((LA(1)==SP)) {
2638 match(SP);
2639 }
2640 else {
2641 break _loop759;
2642 }
2643
2644 } while (true);
2645 }
2646 {
2647 _loop765:
2648 do {
2649 if ((LA(1)==SEP)) {
2650 match(SEP);
2651 {
2652 _loop762:
2653 do {
2654 if ((LA(1)==SP)) {
2655 match(SP);
2656 }
2657 else {
2658 break _loop762;
2659 }
2660
2661 } while (true);
2662 }
2663 anyUserPermission();
2664 {
2665 _loop764:
2666 do {
2667 if ((LA(1)==SP)) {
2668 match(SP);
2669 }
2670 else {
2671 break _loop764;
2672 }
2673
2674 } while (true);
2675 }
2676 }
2677 else {
2678 break _loop765;
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 _cnt782=0;
2749 _loop782:
2750 do {
2751 if ((LA(1)==SP)) {
2752 match(SP);
2753 }
2754 else {
2755 if ( _cnt782>=1 ) { break _loop782; } else {throw new NoViableAltException(LT(1), getFilename());}
2756 }
2757
2758 _cnt782++;
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 _cnt785=0;
2770 _loop785:
2771 do {
2772 if ((LA(1)==SP)) {
2773 match(SP);
2774 }
2775 else {
2776 if ( _cnt785>=1 ) { break _loop785; } else {throw new NoViableAltException(LT(1), getFilename());}
2777 }
2778
2779 _cnt785++;
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 _cnt811=0;
2791 _loop811:
2792 do {
2793 if ((LA(1)==SP)) {
2794 match(SP);
2795 }
2796 else {
2797 if ( _cnt811>=1 ) { break _loop811; } else {throw new NoViableAltException(LT(1), getFilename());}
2798 }
2799
2800 _cnt811++;
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 _cnt814=0;
2812 _loop814:
2813 do {
2814 if ((LA(1)==SP)) {
2815 match(SP);
2816 }
2817 else {
2818 if ( _cnt814>=1 ) { break _loop814; } else {throw new NoViableAltException(LT(1), getFilename());}
2819 }
2820
2821 _cnt814++;
2822 } while (true);
2823 }
2824 baseDistance();
2825 }
2826
2827 public final void specificExclusions() throws RecognitionException, TokenStreamException {
2828
2829
2830 match(OPEN_CURLY);
2831 {
2832 _loop788:
2833 do {
2834 if ((LA(1)==SP)) {
2835 match(SP);
2836 }
2837 else {
2838 break _loop788;
2839 }
2840
2841 } while (true);
2842 }
2843 {
2844 switch ( LA(1)) {
2845 case ID_chopBefore:
2846 case ID_chopAfter:
2847 {
2848 specificExclusion();
2849 {
2850 _loop791:
2851 do {
2852 if ((LA(1)==SP)) {
2853 match(SP);
2854 }
2855 else {
2856 break _loop791;
2857 }
2858
2859 } while (true);
2860 }
2861 {
2862 _loop797:
2863 do {
2864 if ((LA(1)==SEP)) {
2865 match(SEP);
2866 {
2867 _loop794:
2868 do {
2869 if ((LA(1)==SP)) {
2870 match(SP);
2871 }
2872 else {
2873 break _loop794;
2874 }
2875
2876 } while (true);
2877 }
2878 specificExclusion();
2879 {
2880 _loop796:
2881 do {
2882 if ((LA(1)==SP)) {
2883 match(SP);
2884 }
2885 else {
2886 break _loop796;
2887 }
2888
2889 } while (true);
2890 }
2891 }
2892 else {
2893 break _loop797;
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 _loop801:
2940 do {
2941 if ((LA(1)==SP)) {
2942 match(SP);
2943 }
2944 else {
2945 break _loop801;
2946 }
2947
2948 } while (true);
2949 }
2950 match(COLON);
2951 {
2952 _loop803:
2953 do {
2954 if ((LA(1)==SP)) {
2955 match(SP);
2956 }
2957 else {
2958 break _loop803;
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 _loop806:
2972 do {
2973 if ((LA(1)==SP)) {
2974 match(SP);
2975 }
2976 else {
2977 break _loop806;
2978 }
2979
2980 } while (true);
2981 }
2982 match(COLON);
2983 {
2984 _loop808:
2985 do {
2986 if ((LA(1)==SP)) {
2987 match(SP);
2988 }
2989 else {
2990 break _loop808;
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 _loop822:
3010 do {
3011 if ((LA(1)==SP)) {
3012 match(SP);
3013 }
3014 else {
3015 break _loop822;
3016 }
3017
3018 } while (true);
3019 }
3020 match(COLON);
3021 {
3022 _loop824:
3023 do {
3024 if ((LA(1)==SP)) {
3025 match(SP);
3026 }
3027 else {
3028 break _loop824;
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 _loop827:
3042 do {
3043 if ((LA(1)==SP)) {
3044 match(SP);
3045 }
3046 else {
3047 break _loop827;
3048 }
3049
3050 } while (true);
3051 }
3052 match(COLON);
3053 {
3054 _loop829:
3055 do {
3056 if ((LA(1)==SP)) {
3057 match(SP);
3058 }
3059 else {
3060 break _loop829;
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 _loop832:
3074 do {
3075 if ((LA(1)==SP)) {
3076 match(SP);
3077 }
3078 else {
3079 break _loop832;
3080 }
3081
3082 } while (true);
3083 }
3084 match(COLON);
3085 {
3086 _loop834:
3087 do {
3088 if ((LA(1)==SP)) {
3089 match(SP);
3090 }
3091 else {
3092 break _loop834;
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 _loop837:
3106 do {
3107 if ((LA(1)==SP)) {
3108 match(SP);
3109 }
3110 else {
3111 break _loop837;
3112 }
3113
3114 } while (true);
3115 }
3116 match(COLON);
3117 {
3118 _loop839:
3119 do {
3120 if ((LA(1)==SP)) {
3121 match(SP);
3122 }
3123 else {
3124 break _loop839;
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 _loop842:
3138 do {
3139 if ((LA(1)==SP)) {
3140 match(SP);
3141 }
3142 else {
3143 break _loop842;
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 _loop845:
3158 do {
3159 if ((LA(1)==SP)) {
3160 match(SP);
3161 }
3162 else {
3163 break _loop845;
3164 }
3165
3166 } while (true);
3167 }
3168 {
3169 _loop851:
3170 do {
3171 if ((LA(1)==SEP)) {
3172 match(SEP);
3173 {
3174 _loop848:
3175 do {
3176 if ((LA(1)==SP)) {
3177 match(SP);
3178 }
3179 else {
3180 break _loop848;
3181 }
3182
3183 } while (true);
3184 }
3185 refinement();
3186 {
3187 _loop850:
3188 do {
3189 if ((LA(1)==SP)) {
3190 match(SP);
3191 }
3192 else {
3193 break _loop850;
3194 }
3195
3196 } while (true);
3197 }
3198 }
3199 else {
3200 break _loop851;
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 }