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