001// $ANTLR 2.7.7 (20060906): "schemaConverter.g" -> "antlrSchemaConverterParser.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 * Keep the semicolon right next to the package name or else there will be a 024 * bug that comes into the foreground in the new antlr release. 025 */ 026package org.apache.directory.api.converter.schema; 027import java.util.List ; 028import java.util.ArrayList ; 029import java.util.Collections; 030import java.io.IOException; 031 032import org.apache.directory.api.converter.schema.SchemaElement; 033import org.apache.directory.api.ldap.model.schema.UsageEnum; 034import org.apache.directory.api.ldap.model.schema.ObjectClassTypeEnum; 035 036import antlr.TokenBuffer; 037import antlr.TokenStreamException; 038import antlr.TokenStreamIOException; 039import antlr.ANTLRException; 040import antlr.LLkParser; 041import antlr.Token; 042import antlr.TokenStream; 043import antlr.RecognitionException; 044import antlr.NoViableAltException; 045import antlr.MismatchedTokenException; 046import antlr.SemanticException; 047import antlr.ParserSharedInputState; 048import antlr.collections.impl.BitSet; 049 050public class antlrSchemaConverterParser extends antlr.LLkParser implements antlrSchemaTokenTypes 051 { 052 053 private List<SchemaElement> schemaElements = new ArrayList<SchemaElement>(); 054 055 // ------------------------------------------------------------------------ 056 // Public Methods 057 // ------------------------------------------------------------------------ 058 public void clear() 059 { 060 schemaElements.clear(); 061 } 062 063 064 public List<SchemaElement> getSchemaElements() 065 { 066 return Collections.unmodifiableList( schemaElements ); 067 } 068 069protected antlrSchemaConverterParser(TokenBuffer tokenBuf, int k) { 070 super(tokenBuf,k); 071 tokenNames = _tokenNames; 072} 073 074public antlrSchemaConverterParser(TokenBuffer tokenBuf) { 075 this(tokenBuf,5); 076} 077 078protected antlrSchemaConverterParser(TokenStream lexer, int k) { 079 super(lexer,k); 080 tokenNames = _tokenNames; 081} 082 083public antlrSchemaConverterParser(TokenStream lexer) { 084 this(lexer,5); 085} 086 087public antlrSchemaConverterParser(ParserSharedInputState state) { 088 super(state,5); 089 tokenNames = _tokenNames; 090} 091 092 public final void parseSchema() throws RecognitionException, TokenStreamException { 093 094 095 { 096 _loop31: 097 do { 098 switch ( LA(1)) { 099 case LITERAL_attributetype: 100 { 101 attributeType(); 102 break; 103 } 104 case LITERAL_objectclass: 105 { 106 objectClass(); 107 break; 108 } 109 default: 110 { 111 break _loop31; 112 } 113 } 114 } while (true); 115 } 116 match(LITERAL_END); 117 } 118 119 public final void attributeType() throws RecognitionException, TokenStreamException { 120 121 Token oid = null; 122 123 AttributeTypeHolder type = null; 124 125 126 match(LITERAL_attributetype); 127 match(OPEN_PAREN); 128 oid = LT(1); 129 match(NUMERICOID); 130 131 type = new AttributeTypeHolder( oid.getText() ); 132 133 { 134 switch ( LA(1)) { 135 case LITERAL_NAME: 136 { 137 names(type); 138 break; 139 } 140 case CLOSE_PAREN: 141 case DESC: 142 case SYNTAX: 143 case LITERAL_OBSOLETE: 144 case LITERAL_SUP: 145 case 28: 146 case LITERAL_COLLECTIVE: 147 case 30: 148 case LITERAL_EQUALITY: 149 case LITERAL_SUBSTR: 150 case LITERAL_ORDERING: 151 case LITERAL_USAGE: 152 { 153 break; 154 } 155 default: 156 { 157 throw new NoViableAltException(LT(1), getFilename()); 158 } 159 } 160 } 161 { 162 switch ( LA(1)) { 163 case DESC: 164 { 165 attributeTypeDesc(type); 166 break; 167 } 168 case CLOSE_PAREN: 169 case SYNTAX: 170 case LITERAL_OBSOLETE: 171 case LITERAL_SUP: 172 case 28: 173 case LITERAL_COLLECTIVE: 174 case 30: 175 case LITERAL_EQUALITY: 176 case LITERAL_SUBSTR: 177 case LITERAL_ORDERING: 178 case LITERAL_USAGE: 179 { 180 break; 181 } 182 default: 183 { 184 throw new NoViableAltException(LT(1), getFilename()); 185 } 186 } 187 } 188 { 189 switch ( LA(1)) { 190 case LITERAL_OBSOLETE: 191 { 192 match(LITERAL_OBSOLETE); 193 type.setObsolete( true ); 194 break; 195 } 196 case CLOSE_PAREN: 197 case SYNTAX: 198 case LITERAL_SUP: 199 case 28: 200 case LITERAL_COLLECTIVE: 201 case 30: 202 case LITERAL_EQUALITY: 203 case LITERAL_SUBSTR: 204 case LITERAL_ORDERING: 205 case LITERAL_USAGE: 206 { 207 break; 208 } 209 default: 210 { 211 throw new NoViableAltException(LT(1), getFilename()); 212 } 213 } 214 } 215 { 216 switch ( LA(1)) { 217 case LITERAL_SUP: 218 { 219 superior(type); 220 break; 221 } 222 case CLOSE_PAREN: 223 case SYNTAX: 224 case 28: 225 case LITERAL_COLLECTIVE: 226 case 30: 227 case LITERAL_EQUALITY: 228 case LITERAL_SUBSTR: 229 case LITERAL_ORDERING: 230 case LITERAL_USAGE: 231 { 232 break; 233 } 234 default: 235 { 236 throw new NoViableAltException(LT(1), getFilename()); 237 } 238 } 239 } 240 { 241 switch ( LA(1)) { 242 case LITERAL_EQUALITY: 243 { 244 equality(type); 245 break; 246 } 247 case CLOSE_PAREN: 248 case SYNTAX: 249 case 28: 250 case LITERAL_COLLECTIVE: 251 case 30: 252 case LITERAL_SUBSTR: 253 case LITERAL_ORDERING: 254 case LITERAL_USAGE: 255 { 256 break; 257 } 258 default: 259 { 260 throw new NoViableAltException(LT(1), getFilename()); 261 } 262 } 263 } 264 { 265 switch ( LA(1)) { 266 case LITERAL_ORDERING: 267 { 268 ordering(type); 269 break; 270 } 271 case CLOSE_PAREN: 272 case SYNTAX: 273 case 28: 274 case LITERAL_COLLECTIVE: 275 case 30: 276 case LITERAL_SUBSTR: 277 case LITERAL_USAGE: 278 { 279 break; 280 } 281 default: 282 { 283 throw new NoViableAltException(LT(1), getFilename()); 284 } 285 } 286 } 287 { 288 switch ( LA(1)) { 289 case LITERAL_SUBSTR: 290 { 291 substr(type); 292 break; 293 } 294 case CLOSE_PAREN: 295 case SYNTAX: 296 case 28: 297 case LITERAL_COLLECTIVE: 298 case 30: 299 case LITERAL_USAGE: 300 { 301 break; 302 } 303 default: 304 { 305 throw new NoViableAltException(LT(1), getFilename()); 306 } 307 } 308 } 309 { 310 switch ( LA(1)) { 311 case SYNTAX: 312 { 313 syntax(type); 314 break; 315 } 316 case CLOSE_PAREN: 317 case 28: 318 case LITERAL_COLLECTIVE: 319 case 30: 320 case LITERAL_USAGE: 321 { 322 break; 323 } 324 default: 325 { 326 throw new NoViableAltException(LT(1), getFilename()); 327 } 328 } 329 } 330 { 331 switch ( LA(1)) { 332 case 28: 333 { 334 match(28); 335 type.setSingleValue( true ); 336 break; 337 } 338 case CLOSE_PAREN: 339 case LITERAL_COLLECTIVE: 340 case 30: 341 case LITERAL_USAGE: 342 { 343 break; 344 } 345 default: 346 { 347 throw new NoViableAltException(LT(1), getFilename()); 348 } 349 } 350 } 351 { 352 switch ( LA(1)) { 353 case LITERAL_COLLECTIVE: 354 { 355 match(LITERAL_COLLECTIVE); 356 type.setCollective( true ); 357 break; 358 } 359 case CLOSE_PAREN: 360 case 30: 361 case LITERAL_USAGE: 362 { 363 break; 364 } 365 default: 366 { 367 throw new NoViableAltException(LT(1), getFilename()); 368 } 369 } 370 } 371 { 372 switch ( LA(1)) { 373 case 30: 374 { 375 match(30); 376 type.setNoUserModification( true ); 377 break; 378 } 379 case CLOSE_PAREN: 380 case LITERAL_USAGE: 381 { 382 break; 383 } 384 default: 385 { 386 throw new NoViableAltException(LT(1), getFilename()); 387 } 388 } 389 } 390 { 391 switch ( LA(1)) { 392 case LITERAL_USAGE: 393 { 394 usage(type); 395 break; 396 } 397 case CLOSE_PAREN: 398 { 399 break; 400 } 401 default: 402 { 403 throw new NoViableAltException(LT(1), getFilename()); 404 } 405 } 406 } 407 match(CLOSE_PAREN); 408 409 schemaElements.add( type ); 410 411 } 412 413 public final void objectClass() throws RecognitionException, TokenStreamException { 414 415 Token oid = null; 416 417 ObjectClassHolder objectClass = null; 418 419 420 match(LITERAL_objectclass); 421 match(OPEN_PAREN); 422 oid = LT(1); 423 match(NUMERICOID); 424 425 objectClass = new ObjectClassHolder( oid.getText() ); 426 427 { 428 switch ( LA(1)) { 429 case LITERAL_NAME: 430 { 431 objectClassNames(objectClass); 432 break; 433 } 434 case CLOSE_PAREN: 435 case DESC: 436 case LITERAL_OBSOLETE: 437 case LITERAL_ABSTRACT: 438 case LITERAL_STRUCTURAL: 439 case LITERAL_AUXILIARY: 440 case LITERAL_MAY: 441 case LITERAL_MUST: 442 case LITERAL_SUP: 443 { 444 break; 445 } 446 default: 447 { 448 throw new NoViableAltException(LT(1), getFilename()); 449 } 450 } 451 } 452 { 453 switch ( LA(1)) { 454 case DESC: 455 { 456 objectClassDesc(objectClass); 457 break; 458 } 459 case CLOSE_PAREN: 460 case LITERAL_OBSOLETE: 461 case LITERAL_ABSTRACT: 462 case LITERAL_STRUCTURAL: 463 case LITERAL_AUXILIARY: 464 case LITERAL_MAY: 465 case LITERAL_MUST: 466 case LITERAL_SUP: 467 { 468 break; 469 } 470 default: 471 { 472 throw new NoViableAltException(LT(1), getFilename()); 473 } 474 } 475 } 476 { 477 switch ( LA(1)) { 478 case LITERAL_OBSOLETE: 479 { 480 match(LITERAL_OBSOLETE); 481 objectClass.setObsolete( true ); 482 break; 483 } 484 case CLOSE_PAREN: 485 case LITERAL_ABSTRACT: 486 case LITERAL_STRUCTURAL: 487 case LITERAL_AUXILIARY: 488 case LITERAL_MAY: 489 case LITERAL_MUST: 490 case LITERAL_SUP: 491 { 492 break; 493 } 494 default: 495 { 496 throw new NoViableAltException(LT(1), getFilename()); 497 } 498 } 499 } 500 { 501 switch ( LA(1)) { 502 case LITERAL_SUP: 503 { 504 objectClassSuperiors(objectClass); 505 break; 506 } 507 case CLOSE_PAREN: 508 case LITERAL_ABSTRACT: 509 case LITERAL_STRUCTURAL: 510 case LITERAL_AUXILIARY: 511 case LITERAL_MAY: 512 case LITERAL_MUST: 513 { 514 break; 515 } 516 default: 517 { 518 throw new NoViableAltException(LT(1), getFilename()); 519 } 520 } 521 } 522 { 523 switch ( LA(1)) { 524 case LITERAL_ABSTRACT: 525 { 526 match(LITERAL_ABSTRACT); 527 objectClass.setClassType( ObjectClassTypeEnum.ABSTRACT ); 528 break; 529 } 530 case LITERAL_STRUCTURAL: 531 { 532 match(LITERAL_STRUCTURAL); 533 objectClass.setClassType( ObjectClassTypeEnum.STRUCTURAL ); 534 break; 535 } 536 case LITERAL_AUXILIARY: 537 { 538 match(LITERAL_AUXILIARY); 539 objectClass.setClassType( ObjectClassTypeEnum.AUXILIARY ); 540 break; 541 } 542 case CLOSE_PAREN: 543 case LITERAL_MAY: 544 case LITERAL_MUST: 545 { 546 break; 547 } 548 default: 549 { 550 throw new NoViableAltException(LT(1), getFilename()); 551 } 552 } 553 } 554 { 555 switch ( LA(1)) { 556 case LITERAL_MUST: 557 { 558 must(objectClass); 559 break; 560 } 561 case CLOSE_PAREN: 562 case LITERAL_MAY: 563 { 564 break; 565 } 566 default: 567 { 568 throw new NoViableAltException(LT(1), getFilename()); 569 } 570 } 571 } 572 { 573 switch ( LA(1)) { 574 case LITERAL_MAY: 575 { 576 may(objectClass); 577 break; 578 } 579 case CLOSE_PAREN: 580 { 581 break; 582 } 583 default: 584 { 585 throw new NoViableAltException(LT(1), getFilename()); 586 } 587 } 588 } 589 match(CLOSE_PAREN); 590 591 schemaElements.add( objectClass ); 592 593 } 594 595 public final void objectClassNames( 596 ObjectClassHolder objectClass 597 ) throws RecognitionException, TokenStreamException { 598 599 Token id0 = null; 600 Token id1 = null; 601 Token id2 = null; 602 603 List<String> list = new ArrayList<String>(); 604 605 606 { 607 match(LITERAL_NAME); 608 { 609 switch ( LA(1)) { 610 case QUOTE: 611 { 612 match(QUOTE); 613 id0 = LT(1); 614 match(IDENTIFIER); 615 match(QUOTE); 616 617 list.add( id0.getText() ); 618 619 break; 620 } 621 case OPEN_PAREN: 622 { 623 { 624 match(OPEN_PAREN); 625 match(QUOTE); 626 id1 = LT(1); 627 match(IDENTIFIER); 628 629 list.add( id1.getText() ); 630 631 match(QUOTE); 632 { 633 _loop56: 634 do { 635 if ((LA(1)==QUOTE)) { 636 match(QUOTE); 637 id2 = LT(1); 638 match(IDENTIFIER); 639 match(QUOTE); 640 641 list.add( id2.getText() ); 642 643 } 644 else { 645 break _loop56; 646 } 647 648 } while (true); 649 } 650 match(CLOSE_PAREN); 651 } 652 break; 653 } 654 default: 655 { 656 throw new NoViableAltException(LT(1), getFilename()); 657 } 658 } 659 } 660 } 661 662 objectClass.setNames( list ); 663 664 } 665 666 public final void objectClassDesc( 667 ObjectClassHolder objectClass 668 ) throws RecognitionException, TokenStreamException { 669 670 Token d = null; 671 672 d = LT(1); 673 match(DESC); 674 675 String text = d.getText(); 676 int start = text.indexOf( '\'' ); 677 String desc = text.substring( start + 1, text.length() - 1 ); 678 desc = desc.replace( "\\\"", "\"" ); 679 desc = desc.replace( "\\'", "'" ); 680 desc = desc.replace( "\\27", "'" ); 681 desc = desc.replace( "\\5C", "\"" ); 682 objectClass.setDescription( desc ); 683 684 } 685 686 public final void objectClassSuperiors( 687 ObjectClassHolder objectClass 688 ) throws RecognitionException, TokenStreamException { 689 690 691 List<String> list = null; 692 693 694 match(LITERAL_SUP); 695 list=woidlist(); 696 697 objectClass.setSuperiors( list ); 698 699 } 700 701 public final void must( 702 ObjectClassHolder objectClass 703 ) throws RecognitionException, TokenStreamException { 704 705 706 List<String> list = null; 707 708 709 match(LITERAL_MUST); 710 list=woidlist(); 711 712 objectClass.setMust( list ); 713 714 } 715 716 public final void may( 717 ObjectClassHolder objectClass 718 ) throws RecognitionException, TokenStreamException { 719 720 721 List<String> list = null; 722 723 724 match(LITERAL_MAY); 725 list=woidlist(); 726 727 objectClass.setMay( list ); 728 729 } 730 731 public final List<String> woidlist() throws RecognitionException, TokenStreamException { 732 List<String> list; 733 734 735 list = new ArrayList<String>( 2 ); 736 String oid = null; 737 738 739 { 740 switch ( LA(1)) { 741 case NUMERICOID: 742 case IDENTIFIER: 743 { 744 oid=woid(); 745 list.add( oid ); 746 break; 747 } 748 case OPEN_PAREN: 749 { 750 { 751 match(OPEN_PAREN); 752 oid=woid(); 753 list.add( oid ); 754 { 755 _loop49: 756 do { 757 if ((LA(1)==DOLLAR)) { 758 match(DOLLAR); 759 oid=woid(); 760 list.add( oid ); 761 } 762 else { 763 break _loop49; 764 } 765 766 } while (true); 767 } 768 match(CLOSE_PAREN); 769 } 770 break; 771 } 772 default: 773 { 774 throw new NoViableAltException(LT(1), getFilename()); 775 } 776 } 777 } 778 return list; 779 } 780 781 public final String woid() throws RecognitionException, TokenStreamException { 782 String oid; 783 784 Token opt1 = null; 785 Token opt2 = null; 786 787 oid = null; 788 789 790 { 791 switch ( LA(1)) { 792 case NUMERICOID: 793 { 794 opt1 = LT(1); 795 match(NUMERICOID); 796 797 oid = opt1.getText(); 798 799 break; 800 } 801 case IDENTIFIER: 802 { 803 opt2 = LT(1); 804 match(IDENTIFIER); 805 806 oid = opt2.getText(); 807 808 break; 809 } 810 default: 811 { 812 throw new NoViableAltException(LT(1), getFilename()); 813 } 814 } 815 } 816 return oid; 817 } 818 819 public final void names( 820 AttributeTypeHolder type 821 ) throws RecognitionException, TokenStreamException { 822 823 Token id0 = null; 824 Token id1 = null; 825 826 List<String> list = new ArrayList<String>(); 827 828 829 match(LITERAL_NAME); 830 { 831 switch ( LA(1)) { 832 case QUOTE: 833 { 834 match(QUOTE); 835 id0 = LT(1); 836 match(IDENTIFIER); 837 match(QUOTE); 838 839 list.add( id0.getText() ); 840 841 break; 842 } 843 case OPEN_PAREN: 844 { 845 { 846 match(OPEN_PAREN); 847 { 848 int _cnt83=0; 849 _loop83: 850 do { 851 if ((LA(1)==QUOTE)) { 852 match(QUOTE); 853 id1 = LT(1); 854 match(IDENTIFIER); 855 856 list.add( id1.getText() ); 857 858 match(QUOTE); 859 } 860 else { 861 if ( _cnt83>=1 ) { break _loop83; } else {throw new NoViableAltException(LT(1), getFilename());} 862 } 863 864 _cnt83++; 865 } while (true); 866 } 867 match(CLOSE_PAREN); 868 } 869 break; 870 } 871 default: 872 { 873 throw new NoViableAltException(LT(1), getFilename()); 874 } 875 } 876 } 877 878 type.setNames( list ); 879 880 } 881 882 public final void attributeTypeDesc( 883 AttributeTypeHolder type 884 ) throws RecognitionException, TokenStreamException { 885 886 Token d = null; 887 888 d = LT(1); 889 match(DESC); 890 891 String text = d.getText(); 892 int start = text.indexOf( '\'' ); 893 String desc = text.substring( start +1, text.length() - 1 ); 894 desc = desc.replace( "\\\"", "\"" ); 895 desc = desc.replace( "\\'", "'" ); 896 desc = desc.replace( "\\27", "'" ); 897 desc = desc.replace( "\\5C", "\"" ); 898 type.setDescription( desc ); 899 900 } 901 902 public final void superior( 903 AttributeTypeHolder type 904 ) throws RecognitionException, TokenStreamException { 905 906 Token oid = null; 907 Token id = null; 908 909 match(LITERAL_SUP); 910 { 911 switch ( LA(1)) { 912 case NUMERICOID: 913 { 914 oid = LT(1); 915 match(NUMERICOID); 916 917 type.setSuperior( oid.getText() ); 918 919 break; 920 } 921 case IDENTIFIER: 922 { 923 id = LT(1); 924 match(IDENTIFIER); 925 926 type.setSuperior( id.getText() ); 927 928 break; 929 } 930 default: 931 { 932 throw new NoViableAltException(LT(1), getFilename()); 933 } 934 } 935 } 936 } 937 938 public final void equality( 939 AttributeTypeHolder type 940 ) throws RecognitionException, TokenStreamException { 941 942 Token oid = null; 943 Token id = null; 944 945 match(LITERAL_EQUALITY); 946 { 947 switch ( LA(1)) { 948 case NUMERICOID: 949 { 950 oid = LT(1); 951 match(NUMERICOID); 952 953 type.setEquality( oid.getText() ); 954 955 break; 956 } 957 case IDENTIFIER: 958 { 959 id = LT(1); 960 match(IDENTIFIER); 961 962 type.setEquality( id.getText() ); 963 964 break; 965 } 966 default: 967 { 968 throw new NoViableAltException(LT(1), getFilename()); 969 } 970 } 971 } 972 } 973 974 public final void ordering( 975 AttributeTypeHolder type 976 ) throws RecognitionException, TokenStreamException { 977 978 Token oid = null; 979 Token id = null; 980 981 match(LITERAL_ORDERING); 982 { 983 switch ( LA(1)) { 984 case NUMERICOID: 985 { 986 oid = LT(1); 987 match(NUMERICOID); 988 989 type.setOrdering( oid.getText() ); 990 991 break; 992 } 993 case IDENTIFIER: 994 { 995 id = LT(1); 996 match(IDENTIFIER); 997 998 type.setOrdering( id.getText() ); 999 1000 break; 1001 } 1002 default: 1003 { 1004 throw new NoViableAltException(LT(1), getFilename()); 1005 } 1006 } 1007 } 1008 } 1009 1010 public final void substr( 1011 AttributeTypeHolder type 1012 ) throws RecognitionException, TokenStreamException { 1013 1014 Token oid = null; 1015 Token id = null; 1016 1017 match(LITERAL_SUBSTR); 1018 { 1019 switch ( LA(1)) { 1020 case NUMERICOID: 1021 { 1022 oid = LT(1); 1023 match(NUMERICOID); 1024 1025 type.setSubstr( oid.getText() ); 1026 1027 break; 1028 } 1029 case IDENTIFIER: 1030 { 1031 id = LT(1); 1032 match(IDENTIFIER); 1033 1034 type.setSubstr( id.getText() ); 1035 1036 break; 1037 } 1038 default: 1039 { 1040 throw new NoViableAltException(LT(1), getFilename()); 1041 } 1042 } 1043 } 1044 } 1045 1046 public final void syntax( 1047 AttributeTypeHolder type 1048 ) throws RecognitionException, TokenStreamException { 1049 1050 Token token = null; 1051 1052 token = LT(1); 1053 match(SYNTAX); 1054 1055 String[] comps = token.getText().split( " " ); 1056 1057 int index = comps[1].indexOf( "{" ); 1058 if ( index == -1 ) 1059 { 1060 type.setSyntax( comps[1] ); 1061 return; 1062 } 1063 1064 String oid = comps[1].substring( 0, index ); 1065 String length = comps[1].substring( index + 1, comps[1].length() - 1 ); 1066 1067 type.setSyntax( oid ); 1068 type.setOidLen( Long.parseLong( length ) ); 1069 1070 } 1071 1072 public final void usage( 1073 AttributeTypeHolder type 1074 ) throws RecognitionException, TokenStreamException { 1075 1076 1077 match(LITERAL_USAGE); 1078 { 1079 switch ( LA(1)) { 1080 case LITERAL_userApplications: 1081 { 1082 match(LITERAL_userApplications); 1083 type.setUsage( UsageEnum.USER_APPLICATIONS ); 1084 break; 1085 } 1086 case LITERAL_directoryOperation: 1087 { 1088 match(LITERAL_directoryOperation); 1089 type.setUsage( UsageEnum.DIRECTORY_OPERATION ); 1090 break; 1091 } 1092 case LITERAL_distributedOperation: 1093 { 1094 match(LITERAL_distributedOperation); 1095 type.setUsage( UsageEnum.DISTRIBUTED_OPERATION ); 1096 break; 1097 } 1098 case LITERAL_dSAOperation: 1099 { 1100 match(LITERAL_dSAOperation); 1101 type.setUsage( UsageEnum.DSA_OPERATION ); 1102 break; 1103 } 1104 default: 1105 { 1106 throw new NoViableAltException(LT(1), getFilename()); 1107 } 1108 } 1109 } 1110 } 1111 1112 1113 public static final String[] _tokenNames = { 1114 "<0>", 1115 "EOF", 1116 "<2>", 1117 "NULL_TREE_LOOKAHEAD", 1118 "WS", 1119 "QUOTE", 1120 "DIGIT", 1121 "DOLLAR", 1122 "OPEN_PAREN", 1123 "CLOSE_PAREN", 1124 "OPEN_BRACKET", 1125 "CLOSE_BRACKET", 1126 "NUMERIC_STRING", 1127 "NUMERICOID", 1128 "IDENTIFIER", 1129 "DESC", 1130 "SYNTAX", 1131 "\"END\"", 1132 "\"objectclass\"", 1133 "\"OBSOLETE\"", 1134 "\"ABSTRACT\"", 1135 "\"STRUCTURAL\"", 1136 "\"AUXILIARY\"", 1137 "\"MAY\"", 1138 "\"MUST\"", 1139 "\"SUP\"", 1140 "\"NAME\"", 1141 "\"attributetype\"", 1142 "\"SINGLE-VALUE\"", 1143 "\"COLLECTIVE\"", 1144 "\"NO-USER-MODIFICATION\"", 1145 "\"EQUALITY\"", 1146 "\"SUBSTR\"", 1147 "\"ORDERING\"", 1148 "\"USAGE\"", 1149 "\"userApplications\"", 1150 "\"directoryOperation\"", 1151 "\"distributedOperation\"", 1152 "\"dSAOperation\"" 1153 }; 1154 1155 1156 }