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