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.shared.converter.schema;
027import java.util.List ;
028import java.util.ArrayList ;
029import java.util.Collections;
030import java.io.IOException;
031
032import org.apache.directory.shared.converter.schema.SchemaElement;
033import org.apache.directory.shared.ldap.model.schema.UsageEnum;
034import org.apache.directory.shared.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                        desc(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 desc = d.getText().split( "'" )[1];
676                String[] quoted = desc.split( "\"" );
677                
678                if ( quoted.length == 1 )
679                {
680                objectClass.setDescription( desc );
681                }
682                else
683                {
684                StringBuffer buf = new StringBuffer();
685                for ( int ii = 0; ii < quoted.length; ii++ )
686                {
687                if ( ii < quoted.length - 1 )
688                {
689                buf.append( quoted[ii] ).append( "\\" ).append( "\"" );
690                }
691                else
692                {
693                buf.append( quoted[ii] );
694                }
695                }
696                
697                objectClass.setDescription( buf.toString() );
698                }
699                
700        }
701        
702        public final void objectClassSuperiors(
703                ObjectClassHolder objectClass
704        ) throws RecognitionException, TokenStreamException {
705                
706                
707                List<String> list = null;
708                
709                
710                match(LITERAL_SUP);
711                list=woidlist();
712                
713                objectClass.setSuperiors( list );
714                
715        }
716        
717        public final void must(
718                ObjectClassHolder objectClass
719        ) throws RecognitionException, TokenStreamException {
720                
721                
722                List<String> list = null;
723                
724                
725                match(LITERAL_MUST);
726                list=woidlist();
727                
728                objectClass.setMust( list );
729                
730        }
731        
732        public final void may(
733                ObjectClassHolder objectClass
734        ) throws RecognitionException, TokenStreamException {
735                
736                
737                List<String> list = null;
738                
739                
740                match(LITERAL_MAY);
741                list=woidlist();
742                
743                objectClass.setMay( list );
744                
745        }
746        
747        public final List<String>  woidlist() throws RecognitionException, TokenStreamException {
748                List<String> list;
749                
750                
751                list = new ArrayList<String>( 2 );
752                String oid = null;
753                
754                
755                {
756                switch ( LA(1)) {
757                case NUMERICOID:
758                case IDENTIFIER:
759                {
760                        oid=woid();
761                        list.add( oid );
762                        break;
763                }
764                case OPEN_PAREN:
765                {
766                        {
767                        match(OPEN_PAREN);
768                        oid=woid();
769                        list.add( oid );
770                        {
771                        _loop49:
772                        do {
773                                if ((LA(1)==DOLLAR)) {
774                                        match(DOLLAR);
775                                        oid=woid();
776                                        list.add( oid );
777                                }
778                                else {
779                                        break _loop49;
780                                }
781                                
782                        } while (true);
783                        }
784                        match(CLOSE_PAREN);
785                        }
786                        break;
787                }
788                default:
789                {
790                        throw new NoViableAltException(LT(1), getFilename());
791                }
792                }
793                }
794                return list;
795        }
796        
797        public final String  woid() throws RecognitionException, TokenStreamException {
798                String oid;
799                
800                Token  opt1 = null;
801                Token  opt2 = null;
802                
803                oid = null;
804                
805                
806                {
807                switch ( LA(1)) {
808                case NUMERICOID:
809                {
810                        opt1 = LT(1);
811                        match(NUMERICOID);
812                        
813                        oid = opt1.getText();
814                        
815                        break;
816                }
817                case IDENTIFIER:
818                {
819                        opt2 = LT(1);
820                        match(IDENTIFIER);
821                        
822                        oid = opt2.getText();
823                        
824                        break;
825                }
826                default:
827                {
828                        throw new NoViableAltException(LT(1), getFilename());
829                }
830                }
831                }
832                return oid;
833        }
834        
835        public final void names(
836                AttributeTypeHolder type
837        ) throws RecognitionException, TokenStreamException {
838                
839                Token  id0 = null;
840                Token  id1 = null;
841                
842                List<String> list = new ArrayList<String>();
843                
844                
845                match(LITERAL_NAME);
846                {
847                switch ( LA(1)) {
848                case QUOTE:
849                {
850                        match(QUOTE);
851                        id0 = LT(1);
852                        match(IDENTIFIER);
853                        match(QUOTE);
854                        
855                        list.add( id0.getText() ); 
856                        
857                        break;
858                }
859                case OPEN_PAREN:
860                {
861                        {
862                        match(OPEN_PAREN);
863                        {
864                        int _cnt83=0;
865                        _loop83:
866                        do {
867                                if ((LA(1)==QUOTE)) {
868                                        match(QUOTE);
869                                        id1 = LT(1);
870                                        match(IDENTIFIER);
871                                        
872                                        list.add( id1.getText() );
873                                        
874                                        match(QUOTE);
875                                }
876                                else {
877                                        if ( _cnt83>=1 ) { break _loop83; } else {throw new NoViableAltException(LT(1), getFilename());}
878                                }
879                                
880                                _cnt83++;
881                        } while (true);
882                        }
883                        match(CLOSE_PAREN);
884                        }
885                        break;
886                }
887                default:
888                {
889                        throw new NoViableAltException(LT(1), getFilename());
890                }
891                }
892                }
893                
894                type.setNames( list );
895                
896        }
897        
898        public final void desc(
899                AttributeTypeHolder type
900        ) throws RecognitionException, TokenStreamException {
901                
902                Token  d = null;
903                
904                d = LT(1);
905                match(DESC);
906                
907                String desc = d.getText().split( "'" )[1];
908                String[] quoted = desc.split( "\"" );
909                
910                if ( quoted.length == 1 )
911                {
912                type.setDescription( desc );
913                }
914                else
915                {
916                StringBuffer buf = new StringBuffer();
917                for ( int ii = 0; ii < quoted.length; ii++ )
918                {
919                if ( ii < quoted.length - 1 )
920                {
921                buf.append( quoted[ii] ).append( "\\" ).append( "\"" );
922                }
923                else
924                {
925                buf.append( quoted[ii] );
926                }
927                }
928                
929                type.setDescription( buf.toString() );
930                }
931                
932        }
933        
934        public final void superior(
935                AttributeTypeHolder type
936        ) throws RecognitionException, TokenStreamException {
937                
938                Token  oid = null;
939                Token  id = null;
940                
941                match(LITERAL_SUP);
942                {
943                switch ( LA(1)) {
944                case NUMERICOID:
945                {
946                        oid = LT(1);
947                        match(NUMERICOID);
948                        
949                        type.setSuperior( oid.getText() );
950                        
951                        break;
952                }
953                case IDENTIFIER:
954                {
955                        id = LT(1);
956                        match(IDENTIFIER);
957                        
958                        type.setSuperior( id.getText() );
959                        
960                        break;
961                }
962                default:
963                {
964                        throw new NoViableAltException(LT(1), getFilename());
965                }
966                }
967                }
968        }
969        
970        public final void equality(
971                AttributeTypeHolder type
972        ) throws RecognitionException, TokenStreamException {
973                
974                Token  oid = null;
975                Token  id = null;
976                
977                match(LITERAL_EQUALITY);
978                {
979                switch ( LA(1)) {
980                case NUMERICOID:
981                {
982                        oid = LT(1);
983                        match(NUMERICOID);
984                        
985                        type.setEquality( oid.getText() );
986                        
987                        break;
988                }
989                case IDENTIFIER:
990                {
991                        id = LT(1);
992                        match(IDENTIFIER);
993                        
994                        type.setEquality( id.getText() );
995                        
996                        break;
997                }
998                default:
999                {
1000                        throw new NoViableAltException(LT(1), getFilename());
1001                }
1002                }
1003                }
1004        }
1005        
1006        public final void ordering(
1007                AttributeTypeHolder type
1008        ) throws RecognitionException, TokenStreamException {
1009                
1010                Token  oid = null;
1011                Token  id = null;
1012                
1013                match(LITERAL_ORDERING);
1014                {
1015                switch ( LA(1)) {
1016                case NUMERICOID:
1017                {
1018                        oid = LT(1);
1019                        match(NUMERICOID);
1020                        
1021                        type.setOrdering( oid.getText() );
1022                        
1023                        break;
1024                }
1025                case IDENTIFIER:
1026                {
1027                        id = LT(1);
1028                        match(IDENTIFIER);
1029                        
1030                        type.setOrdering( id.getText() );
1031                        
1032                        break;
1033                }
1034                default:
1035                {
1036                        throw new NoViableAltException(LT(1), getFilename());
1037                }
1038                }
1039                }
1040        }
1041        
1042        public final void substr(
1043                AttributeTypeHolder type
1044        ) throws RecognitionException, TokenStreamException {
1045                
1046                Token  oid = null;
1047                Token  id = null;
1048                
1049                match(LITERAL_SUBSTR);
1050                {
1051                switch ( LA(1)) {
1052                case NUMERICOID:
1053                {
1054                        oid = LT(1);
1055                        match(NUMERICOID);
1056                        
1057                        type.setSubstr( oid.getText() );
1058                        
1059                        break;
1060                }
1061                case IDENTIFIER:
1062                {
1063                        id = LT(1);
1064                        match(IDENTIFIER);
1065                        
1066                        type.setSubstr( id.getText() );
1067                        
1068                        break;
1069                }
1070                default:
1071                {
1072                        throw new NoViableAltException(LT(1), getFilename());
1073                }
1074                }
1075                }
1076        }
1077        
1078        public final void syntax(
1079                AttributeTypeHolder type
1080        ) throws RecognitionException, TokenStreamException {
1081                
1082                Token  token = null;
1083                
1084                token = LT(1);
1085                match(SYNTAX);
1086                
1087                String[] comps = token.getText().split( " " );
1088                
1089                int index = comps[1].indexOf( "{" );
1090                if ( index == -1 )
1091                {
1092                type.setSyntax( comps[1] );
1093                return;
1094                }
1095                
1096                String oid = comps[1].substring( 0, index );
1097                String length = comps[1].substring( index + 1, comps[1].length() - 1 );
1098                
1099                type.setSyntax( oid );
1100                type.setOidLen( Integer.parseInt( length ) );
1101                
1102        }
1103        
1104        public final void usage(
1105                AttributeTypeHolder type
1106        ) throws RecognitionException, TokenStreamException {
1107                
1108                
1109                match(LITERAL_USAGE);
1110                {
1111                switch ( LA(1)) {
1112                case LITERAL_userApplications:
1113                {
1114                        match(LITERAL_userApplications);
1115                        type.setUsage( UsageEnum.USER_APPLICATIONS );
1116                        break;
1117                }
1118                case LITERAL_directoryOperation:
1119                {
1120                        match(LITERAL_directoryOperation);
1121                        type.setUsage( UsageEnum.DIRECTORY_OPERATION );
1122                        break;
1123                }
1124                case LITERAL_distributedOperation:
1125                {
1126                        match(LITERAL_distributedOperation);
1127                        type.setUsage( UsageEnum.DISTRIBUTED_OPERATION );
1128                        break;
1129                }
1130                case LITERAL_dSAOperation:
1131                {
1132                        match(LITERAL_dSAOperation);
1133                        type.setUsage( UsageEnum.DSA_OPERATION );
1134                        break;
1135                }
1136                default:
1137                {
1138                        throw new NoViableAltException(LT(1), getFilename());
1139                }
1140                }
1141                }
1142        }
1143        
1144        
1145        public static final String[] _tokenNames = {
1146                "<0>",
1147                "EOF",
1148                "<2>",
1149                "NULL_TREE_LOOKAHEAD",
1150                "WS",
1151                "QUOTE",
1152                "DIGIT",
1153                "DOLLAR",
1154                "OPEN_PAREN",
1155                "CLOSE_PAREN",
1156                "OPEN_BRACKET",
1157                "CLOSE_BRACKET",
1158                "NUMERIC_STRING",
1159                "NUMERICOID",
1160                "IDENTIFIER",
1161                "DESC",
1162                "SYNTAX",
1163                "\"END\"",
1164                "\"objectclass\"",
1165                "\"OBSOLETE\"",
1166                "\"ABSTRACT\"",
1167                "\"STRUCTURAL\"",
1168                "\"AUXILIARY\"",
1169                "\"MAY\"",
1170                "\"MUST\"",
1171                "\"SUP\"",
1172                "\"NAME\"",
1173                "\"attributetype\"",
1174                "\"SINGLE-VALUE\"",
1175                "\"COLLECTIVE\"",
1176                "\"NO-USER-MODIFICATION\"",
1177                "\"EQUALITY\"",
1178                "\"SUBSTR\"",
1179                "\"ORDERING\"",
1180                "\"USAGE\"",
1181                "\"userApplications\"",
1182                "\"directoryOperation\"",
1183                "\"distributedOperation\"",
1184                "\"dSAOperation\""
1185        };
1186        
1187        
1188        }