1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 package org.apache.directory.api.ldap.schema.converter;
27 import java.util.List ;
28 import java.util.ArrayList ;
29 import java.util.Collections;
30 import java.io.IOException;
31
32 import org.apache.directory.api.ldap.schema.converter.SchemaElement;
33 import org.apache.directory.api.ldap.model.schema.UsageEnum;
34 import org.apache.directory.api.ldap.model.schema.ObjectClassTypeEnum;
35
36 import antlr.TokenBuffer;
37 import antlr.TokenStreamException;
38 import antlr.TokenStreamIOException;
39 import antlr.ANTLRException;
40 import antlr.LLkParser;
41 import antlr.Token;
42 import antlr.TokenStream;
43 import antlr.RecognitionException;
44 import antlr.NoViableAltException;
45 import antlr.MismatchedTokenException;
46 import antlr.SemanticException;
47 import antlr.ParserSharedInputState;
48 import antlr.collections.impl.BitSet;
49
50 public class antlrSchemaConverterParser extends antlr.LLkParser implements antlrSchemaTokenTypes
51 {
52
53 private List<SchemaElement> schemaElements = new ArrayList<SchemaElement>();
54
55
56
57
58 public void clear()
59 {
60 schemaElements.clear();
61 }
62
63
64 public List<SchemaElement> getSchemaElements()
65 {
66 return Collections.unmodifiableList( schemaElements );
67 }
68
69 protected antlrSchemaConverterParser(TokenBuffer tokenBuf, int k) {
70 super(tokenBuf,k);
71 tokenNames = _tokenNames;
72 }
73
74 public antlrSchemaConverterParser(TokenBuffer tokenBuf) {
75 this(tokenBuf,5);
76 }
77
78 protected antlrSchemaConverterParser(TokenStream lexer, int k) {
79 super(lexer,k);
80 tokenNames = _tokenNames;
81 }
82
83 public antlrSchemaConverterParser(TokenStream lexer) {
84 this(lexer,5);
85 }
86
87 public antlrSchemaConverterParser(ParserSharedInputState state) {
88 super(state,5);
89 tokenNames = _tokenNames;
90 }
91
92 public final void parseSchema() throws RecognitionException, TokenStreamException {
93
94
95 {
96 _loop31:
97 do {
98 switch ( LA(1)) {
99 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 }