Source code

001// $ANTLR 2.7.7 (20060906): "schema.g" -> "AntlrSchemaParser.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 */
022package org.apache.directory.shared.ldap.model.schema.syntaxes;
023
024import java.io.StringReader;
025import java.util.ArrayList;
026import java.util.HashMap;
027import java.util.List;
028import java.util.Map;
029
030import org.apache.directory.shared.ldap.model.schema.parsers.LdapComparatorDescription;
031import org.apache.directory.shared.ldap.model.schema.DITContentRule;
032import org.apache.directory.shared.ldap.model.schema.DITStructureRule;
033import org.apache.directory.shared.ldap.model.schema.LdapSyntax;
034import org.apache.directory.shared.ldap.model.schema.MatchingRule;
035import org.apache.directory.shared.ldap.model.schema.MatchingRuleUse;
036import org.apache.directory.shared.ldap.model.schema.NameForm;
037import org.apache.directory.shared.ldap.model.schema.parsers.NormalizerDescription;
038import org.apache.directory.shared.ldap.model.schema.parsers.ParserMonitor;
039import org.apache.directory.shared.ldap.model.schema.AttributeType;
040import org.apache.directory.shared.ldap.model.schema.ObjectClass;
041import org.apache.directory.shared.ldap.model.schema.parsers.SyntaxCheckerDescription;
042import org.apache.directory.shared.ldap.model.schema.syntaxCheckers.OpenLdapObjectIdentifierMacro;
043import org.apache.directory.shared.ldap.model.schema.ObjectClassTypeEnum;
044import org.apache.directory.shared.ldap.model.schema.UsageEnum;
045
046
047import antlr.TokenBuffer;
048import antlr.TokenStreamException;
049import antlr.TokenStreamIOException;
050import antlr.ANTLRException;
051import antlr.LLkParser;
052import antlr.Token;
053import antlr.TokenStream;
054import antlr.RecognitionException;
055import antlr.NoViableAltException;
056import antlr.MismatchedTokenException;
057import antlr.SemanticException;
058import antlr.ParserSharedInputState;
059import antlr.collections.impl.BitSet;
060
061/**
062 * An antlr generated schema main parser.
063 *
064 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
065 */
066public class AntlrSchemaParser extends antlr.LLkParser       implements AntlrSchemaTokenTypes
067 {
068
069    private ParserMonitor monitor = null;
070    private boolean isQuirksModeEnabled = false;
071    public void setParserMonitor( ParserMonitor monitor )
072    {
073        this.monitor = monitor;
074    }
075    private void matchedProduction( String msg )
076    {
077        if ( null != monitor )
078        {
079            monitor.matchedProduction( msg );
080        }
081    }
082    public void setQuirksMode( boolean enabled )
083    {
084        this.isQuirksModeEnabled = enabled;
085    }
086    public boolean isQuirksMode()
087    {
088        return this.isQuirksModeEnabled;
089    }
090    static class Extension
091    {
092        String key = "";
093        List<String> values = new ArrayList<String>();
094        
095        public void addValue( String value )
096        {
097            this.values.add( value );
098        }
099    }
100    static class NoidLen
101    {
102        String noid = "";
103        long len = 0L;
104    }
105    static class ElementTracker
106    {
107        Map<String, Integer> elementMap = new HashMap<String, Integer>();
108        void track(String element, Token token) throws SemanticException 
109        {
110            if(elementMap.containsKey(element))
111            {
112                throw new SemanticException( element + " appears twice.", token.getFilename(), token.getLine() , token.getColumn() );
113            }
114            elementMap.put(element, Integer.valueOf(1));
115        }
116        boolean contains(String element) 
117        {
118            return elementMap.containsKey(element);
119        }
120    }
121
122
123protected AntlrSchemaParser(TokenBuffer tokenBuf, int k) {
124  super(tokenBuf,k);
125  tokenNames = _tokenNames;
126}
127
128public AntlrSchemaParser(TokenBuffer tokenBuf) {
129  this(tokenBuf,3);
130}
131
132protected AntlrSchemaParser(TokenStream lexer, int k) {
133  super(lexer,k);
134  tokenNames = _tokenNames;
135}
136
137public AntlrSchemaParser(TokenStream lexer) {
138  this(lexer,3);
139}
140
141public AntlrSchemaParser(ParserSharedInputState state) {
142  super(state,3);
143  tokenNames = _tokenNames;
144}
145
146        public final List<Object>  openLdapSchema() throws RecognitionException, TokenStreamException {
147                List<Object> list = new ArrayList<Object>();
148                
149                
150                AttributeType attributeType = null;
151                ObjectClass objectClass = null;
152                OpenLdapObjectIdentifierMacro oloid = null;
153                
154                
155                {
156                _loop155:
157                do {
158                        switch ( LA(1)) {
159                        case OBJECTIDENTIFIER:
160                        {
161                                oloid=openLdapObjectIdentifier();
162                                list.add( oloid );
163                                break;
164                        }
165                        case ATTRIBUTETYPE:
166                        {
167                                attributeType=openLdapAttributeType();
168                                list.add( attributeType );
169                                break;
170                        }
171                        case OBJECTCLASS:
172                        {
173                                objectClass=openLdapObjectClass();
174                                list.add( objectClass );
175                                break;
176                        }
177                        default:
178                        {
179                                break _loop155;
180                        }
181                        }
182                } while (true);
183                }
184                return list;
185        }
186        
187        public final OpenLdapObjectIdentifierMacro  openLdapObjectIdentifier() throws RecognitionException, TokenStreamException {
188                OpenLdapObjectIdentifierMacro oloid;
189                
190                Token  oi = null;
191                
192                matchedProduction( "openLdapObjectIdentifier()" );
193                
194                
195                {
196                oi = LT(1);
197                match(OBJECTIDENTIFIER);
198                
199                String[] nameAndValue = oi.getText().split( " " );
200                oloid = new OpenLdapObjectIdentifierMacro();
201                oloid.setName( nameAndValue[0] );
202                oloid.setRawOidOrNameSuffix( nameAndValue[1] );
203                
204                }
205                return oloid;
206        }
207        
208        public final AttributeType  openLdapAttributeType() throws RecognitionException, TokenStreamException {
209                AttributeType attributeType;
210                
211                
212                matchedProduction( "openLdapAttributeType()" );
213                
214                
215                {
216                match(ATTRIBUTETYPE);
217                {
218                attributeType=attributeTypeDescription();
219                }
220                }
221                return attributeType;
222        }
223        
224        public final ObjectClass  openLdapObjectClass() throws RecognitionException, TokenStreamException {
225                ObjectClass objectClass;
226                
227                
228                matchedProduction( "openLdapObjectClass()" );
229                
230                
231                {
232                match(OBJECTCLASS);
233                {
234                objectClass=objectClassDescription();
235                }
236                }
237                return objectClass;
238        }
239        
240/**
241     * Production for matching object class descriptions. It is fault-tolerant
242     * against element ordering.
243     *
244     * <pre>
245     * ObjectClassDescription = LPAREN WSP
246     *     numericoid                 ; object identifier
247     *     [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
248     *     [ SP "DESC" SP qdstring ]  ; description
249     *     [ SP "OBSOLETE" ]          ; not active
250     *     [ SP "SUP" SP oids ]       ; superior object classes
251     *     [ SP kind ]                ; kind of class
252     *     [ SP "MUST" SP oids ]      ; attribute types
253     *     [ SP "MAY" SP oids ]       ; attribute types
254     *     extensions WSP RPAREN
255     *
256     * kind = "ABSTRACT" / "STRUCTURAL" / "AUXILIARY"
257     * 
258     * extensions = *( SP xstring SP qdstrings )
259     * xstring = "X" HYPHEN 1*( ALPHA / HYPHEN / USCORE ) 
260     * </pre>
261    */
262        public final ObjectClass  objectClassDescription() throws RecognitionException, TokenStreamException {
263                ObjectClass objectClass;
264                
265                Token  oid = null;
266                Token  name = null;
267                Token  desc = null;
268                Token  obsolete = null;
269                Token  sup = null;
270                Token  kind1 = null;
271                Token  kind2 = null;
272                Token  kind3 = null;
273                Token  must = null;
274                Token  may = null;
275                Token  extension = null;
276                
277                matchedProduction( "objectClassDescription()" );
278                ElementTracker et = new ElementTracker();
279                
280                
281                {
282                oid = LT(1);
283                match(STARTNUMERICOID);
284                objectClass = new ObjectClass(numericoid(oid.getText()));
285                }
286                {
287                _loop175:
288                do {
289                        switch ( LA(1)) {
290                        case NAME:
291                        {
292                                {
293                                name = LT(1);
294                                match(NAME);
295                                et.track("NAME", name); objectClass.setNames(qdescrs(name.getText()));
296                                }
297                                break;
298                        }
299                        case DESC:
300                        {
301                                {
302                                desc = LT(1);
303                                match(DESC);
304                                et.track("DESC", desc); objectClass.setDescription(qdstring(desc.getText()));
305                                }
306                                break;
307                        }
308                        case OBSOLETE:
309                        {
310                                {
311                                obsolete = LT(1);
312                                match(OBSOLETE);
313                                et.track("OBSOLETE", obsolete); objectClass.setObsolete( true );
314                                }
315                                break;
316                        }
317                        case SUP:
318                        {
319                                {
320                                sup = LT(1);
321                                match(SUP);
322                                et.track("SUP", sup); objectClass.setSuperiorOids(oids(sup.getText()));
323                                }
324                                break;
325                        }
326                        case ABSTRACT:
327                        case STRUCTURAL:
328                        case AUXILIARY:
329                        {
330                                {
331                                switch ( LA(1)) {
332                                case ABSTRACT:
333                                {
334                                        kind1 = LT(1);
335                                        match(ABSTRACT);
336                                        et.track("KIND", kind1); objectClass.setType( ObjectClassTypeEnum.ABSTRACT );
337                                        break;
338                                }
339                                case STRUCTURAL:
340                                {
341                                        kind2 = LT(1);
342                                        match(STRUCTURAL);
343                                        et.track("KIND", kind2); objectClass.setType( ObjectClassTypeEnum.STRUCTURAL );
344                                        break;
345                                }
346                                case AUXILIARY:
347                                {
348                                        kind3 = LT(1);
349                                        match(AUXILIARY);
350                                        et.track("KIND", kind3); objectClass.setType( ObjectClassTypeEnum.AUXILIARY );
351                                        break;
352                                }
353                                default:
354                                {
355                                        throw new NoViableAltException(LT(1), getFilename());
356                                }
357                                }
358                                }
359                                break;
360                        }
361                        case MUST:
362                        {
363                                {
364                                must = LT(1);
365                                match(MUST);
366                                et.track("MUST", must); objectClass.setMustAttributeTypeOids(oids(must.getText()));
367                                }
368                                break;
369                        }
370                        case MAY:
371                        {
372                                {
373                                may = LT(1);
374                                match(MAY);
375                                et.track("MAY", may); objectClass.setMayAttributeTypeOids(oids(may.getText()));
376                                }
377                                break;
378                        }
379                        case EXTENSION:
380                        {
381                                {
382                                extension = LT(1);
383                                match(EXTENSION);
384                                
385                                Extension ex = extension(extension.getText());
386                                et.track(ex.key, extension); 
387                                objectClass.addExtension(ex.key, ex.values); 
388                                
389                                }
390                                break;
391                        }
392                        default:
393                        {
394                                break _loop175;
395                        }
396                        }
397                } while (true);
398                }
399                match(RPAR);
400                return objectClass;
401        }
402        
403/**
404     * Production for matching attribute type descriptions. It is fault-tolerant
405     * against element ordering.
406     *
407     * <pre>
408     * AttributeTypeDescription = LPAREN WSP
409     *     numericoid                    ; object identifier
410     *     [ SP "NAME" SP qdescrs ]      ; short names (descriptors)
411     *     [ SP "DESC" SP qdstring ]     ; description
412     *     [ SP "OBSOLETE" ]             ; not active
413     *     [ SP "SUP" SP oid ]           ; supertype
414     *     [ SP "EQUALITY" SP oid ]      ; equality matching rule
415     *     [ SP "ORDERING" SP oid ]      ; ordering matching rule
416     *     [ SP "SUBSTR" SP oid ]        ; substrings matching rule
417     *     [ SP "SYNTAX" SP noidlen ]    ; value syntax
418     *     [ SP "SINGLE-VALUE" ]         ; single-value
419     *     [ SP "COLLECTIVE" ]           ; collective
420     *     [ SP "NO-USER-MODIFICATION" ] ; not user modifiable
421     *     [ SP "USAGE" SP usage ]       ; usage
422     *     extensions WSP RPAREN         ; extensions
423     * 
424     * usage = "userApplications"     /  ; user
425     *         "directoryOperation"   /  ; directory operational
426     *         "distributedOperation" /  ; DSA-shared operational
427     *         "dSAOperation"            ; DSA-specific operational     
428     * 
429     * extensions = *( SP xstring SP qdstrings )
430     * xstring = "X" HYPHEN 1*( ALPHA / HYPHEN / USCORE ) 
431     * </pre>
432    */
433        public final AttributeType  attributeTypeDescription() throws RecognitionException, TokenStreamException {
434                AttributeType attributeType;
435                
436                Token  oid = null;
437                Token  name = null;
438                Token  desc = null;
439                Token  obsolete = null;
440                Token  superior = null;
441                Token  equality = null;
442                Token  ordering = null;
443                Token  substring = null;
444                Token  syntax = null;
445                Token  singleValued = null;
446                Token  collective = null;
447                Token  noUserModification = null;
448                Token  usage1 = null;
449                Token  usage2 = null;
450                Token  usage3 = null;
451                Token  usage4 = null;
452                Token  extension = null;
453                
454                matchedProduction( "attributeTypeDescription()" );
455                ElementTracker et = new ElementTracker();
456                
457                
458                {
459                oid = LT(1);
460                match(STARTNUMERICOID);
461                attributeType = new AttributeType(numericoid(oid.getText()));
462                }
463                {
464                _loop194:
465                do {
466                        switch ( LA(1)) {
467                        case NAME:
468                        {
469                                {
470                                name = LT(1);
471                                match(NAME);
472                                et.track("NAME", name); attributeType.setNames(qdescrs(name.getText()));
473                                }
474                                break;
475                        }
476                        case DESC:
477                        {
478                                {
479                                desc = LT(1);
480                                match(DESC);
481                                et.track("DESC", desc); attributeType.setDescription(qdstring(desc.getText()));
482                                }
483                                break;
484                        }
485                        case OBSOLETE:
486                        {
487                                {
488                                obsolete = LT(1);
489                                match(OBSOLETE);
490                                et.track("OBSOLETE", obsolete); attributeType.setObsolete( true );
491                                }
492                                break;
493                        }
494                        case SUP:
495                        {
496                                {
497                                superior = LT(1);
498                                match(SUP);
499                                et.track("SUP", superior); attributeType.setSuperiorOid(oid(superior.getText()));
500                                }
501                                break;
502                        }
503                        case EQUALITY:
504                        {
505                                {
506                                equality = LT(1);
507                                match(EQUALITY);
508                                et.track("EQUALITY", equality); attributeType.setEqualityOid(oid(equality.getText()));
509                                }
510                                break;
511                        }
512                        case ORDERING:
513                        {
514                                {
515                                ordering = LT(1);
516                                match(ORDERING);
517                                et.track("ORDERING", ordering); attributeType.setOrderingOid(oid(ordering.getText()));
518                                }
519                                break;
520                        }
521                        case SUBSTR:
522                        {
523                                {
524                                substring = LT(1);
525                                match(SUBSTR);
526                                et.track("SUBSTR", substring); attributeType.setSubstringOid(oid(substring.getText()));
527                                }
528                                break;
529                        }
530                        case SYNTAX:
531                        {
532                                {
533                                syntax = LT(1);
534                                match(SYNTAX);
535                                
536                                et.track("SYNTAX", syntax); 
537                                NoidLen noidlen = noidlen(syntax.getText());
538                                attributeType.setSyntaxOid(noidlen.noid); 
539                                attributeType.setSyntaxLength(noidlen.len);
540                                
541                                }
542                                break;
543                        }
544                        case SINGLE_VALUE:
545                        {
546                                {
547                                singleValued = LT(1);
548                                match(SINGLE_VALUE);
549                                et.track("SINGLE_VALUE", singleValued); attributeType.setSingleValued( true );
550                                }
551                                break;
552                        }
553                        case COLLECTIVE:
554                        {
555                                {
556                                collective = LT(1);
557                                match(COLLECTIVE);
558                                et.track("COLLECTIVE", collective); attributeType.setCollective( true );
559                                }
560                                break;
561                        }
562                        case NO_USER_MODIFICATION:
563                        {
564                                {
565                                noUserModification = LT(1);
566                                match(NO_USER_MODIFICATION);
567                                et.track("NO_USER_MODIFICATION", noUserModification); attributeType.setUserModifiable( false );
568                                }
569                                break;
570                        }
571                        case USAGE:
572                        {
573                                {
574                                if ((LA(1)==USAGE) && (LA(2)==WHSP||LA(2)==USER_APPLICATIONS)) {
575                                        usage1 = LT(1);
576                                        match(USAGE);
577                                        {
578                                        _loop192:
579                                        do {
580                                                if ((LA(1)==WHSP)) {
581                                                        match(WHSP);
582                                                }
583                                                else {
584                                                        break _loop192;
585                                                }
586                                                
587                                        } while (true);
588                                        }
589                                        match(USER_APPLICATIONS);
590                                        et.track("USAGE", usage1); attributeType.setUsage( UsageEnum.USER_APPLICATIONS );
591                                }
592                                else if ((LA(1)==USAGE) && (LA(2)==DIRECTORY_OPERATION)) {
593                                        usage2 = LT(1);
594                                        match(USAGE);
595                                        match(DIRECTORY_OPERATION);
596                                        et.track("USAGE", usage2); attributeType.setUsage( UsageEnum.DIRECTORY_OPERATION );
597                                }
598                                else if ((LA(1)==USAGE) && (LA(2)==DISTRIBUTED_OPERATION)) {
599                                        usage3 = LT(1);
600                                        match(USAGE);
601                                        match(DISTRIBUTED_OPERATION);
602                                        et.track("USAGE", usage3); attributeType.setUsage( UsageEnum.DISTRIBUTED_OPERATION );
603                                }
604                                else if ((LA(1)==USAGE) && (LA(2)==DSA_OPERATION)) {
605                                        usage4 = LT(1);
606                                        match(USAGE);
607                                        match(DSA_OPERATION);
608                                        et.track("USAGE", usage4); attributeType.setUsage( UsageEnum.DSA_OPERATION );
609                                }
610                                else {
611                                        throw new NoViableAltException(LT(1), getFilename());
612                                }
613                                
614                                }
615                                break;
616                        }
617                        case EXTENSION:
618                        {
619                                {
620                                extension = LT(1);
621                                match(EXTENSION);
622                                
623                                Extension ex = extension(extension.getText());
624                                et.track(ex.key, extension); 
625                                attributeType.addExtension(ex.key, ex.values); 
626                                
627                                }
628                                break;
629                        }
630                        default:
631                        {
632                                break _loop194;
633                        }
634                        }
635                } while (true);
636                }
637                match(RPAR);
638                
639                if( !isQuirksModeEnabled )
640                {
641                // semantic check: required elements
642                if( !et.contains("SYNTAX") && !et.contains("SUP") ) 
643                {
644                throw new SemanticException( "One of SYNTAX or SUP is required", null, 0, 0 );
645                }
646                
647                // COLLECTIVE requires USAGE userApplications
648                if ( attributeType.isCollective() && ( attributeType.getUsage() != UsageEnum.USER_APPLICATIONS ) )
649                {
650                throw new SemanticException( "COLLECTIVE requires USAGE userApplications", null, 0, 0 );
651                }
652                
653                // NO-USER-MODIFICATION requires an operational USAGE.
654                if ( !attributeType.isUserModifiable() && ( attributeType.getUsage() == UsageEnum.USER_APPLICATIONS ) )
655                {
656                throw new SemanticException( "NO-USER-MODIFICATION requires an operational USAGE", null, 0, 0 );
657                }
658                }
659                
660                return attributeType;
661        }
662        
663/**
664     * Production for matching ldap syntax descriptions. It is fault-tolerant
665     * against element ordering.
666     *
667     * <pre>
668     * SyntaxDescription = LPAREN WSP
669     *    numericoid                 ; object identifier
670     *    [ SP "DESC" SP qdstring ]  ; description
671     *    extensions WSP RPAREN      ; extensions
672     * </pre>
673    */
674        public final LdapSyntax  ldapSyntaxDescription() throws RecognitionException, TokenStreamException {
675                LdapSyntax ldapSyntax;
676                
677                Token  oid = null;
678                Token  name = null;
679                Token  desc = null;
680                Token  extension = null;
681                
682                matchedProduction( "ldapSyntaxDescription()" );
683                ElementTracker et = new ElementTracker();
684                
685                
686                {
687                oid = LT(1);
688                match(STARTNUMERICOID);
689                ldapSyntax = new LdapSyntax(numericoid(oid.getText()));
690                }
691                {
692                _loop201:
693                do {
694                        switch ( LA(1)) {
695                        case NAME:
696                        {
697                                {
698                                name = LT(1);
699                                match(NAME);
700                                et.track("NAME", name); ldapSyntax.setNames(qdescrs(name.getText()));
701                                }
702                                break;
703                        }
704                        case DESC:
705                        {
706                                {
707                                desc = LT(1);
708                                match(DESC);
709                                et.track("DESC", desc); ldapSyntax.setDescription(qdstring(desc.getText()));
710                                }
711                                break;
712                        }
713                        case EXTENSION:
714                        {
715                                {
716                                extension = LT(1);
717                                match(EXTENSION);
718                                
719                                Extension ex = extension(extension.getText());
720                                et.track(ex.key, extension); 
721                                ldapSyntax.addExtension(ex.key, ex.values); 
722                                
723                                }
724                                break;
725                        }
726                        default:
727                        {
728                                break _loop201;
729                        }
730                        }
731                } while (true);
732                }
733                match(RPAR);
734                return ldapSyntax;
735        }
736        
737/**
738     * Production for matching rule descriptions. It is fault-tolerant
739     * against element ordering.
740     *
741     * <pre>
742     * MatchingRuleDescription = LPAREN WSP
743     *    numericoid                 ; object identifier
744     *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
745     *    [ SP "DESC" SP qdstring ]  ; description
746     *    [ SP "OBSOLETE" ]          ; not active
747     *    SP "SYNTAX" SP numericoid  ; assertion syntax
748     *    extensions WSP RPAREN      ; extensions
749     * </pre>
750    */
751        public final MatchingRule  matchingRuleDescription() throws RecognitionException, TokenStreamException {
752                MatchingRule matchingRule;
753                
754                Token  oid = null;
755                Token  name = null;
756                Token  desc = null;
757                Token  obsolete = null;
758                Token  syntax = null;
759                Token  extension = null;
760                
761                matchedProduction( "matchingRuleDescription()" );
762                ElementTracker et = new ElementTracker();
763                
764                
765                {
766                oid = LT(1);
767                match(STARTNUMERICOID);
768                matchingRule = new MatchingRule(numericoid(oid.getText()));
769                }
770                {
771                _loop210:
772                do {
773                        switch ( LA(1)) {
774                        case NAME:
775                        {
776                                {
777                                name = LT(1);
778                                match(NAME);
779                                et.track("NAME", name); matchingRule.setNames(qdescrs(name.getText()));
780                                }
781                                break;
782                        }
783                        case DESC:
784                        {
785                                {
786                                desc = LT(1);
787                                match(DESC);
788                                et.track("DESC", desc); matchingRule.setDescription(qdstring(desc.getText()));
789                                }
790                                break;
791                        }
792                        case OBSOLETE:
793                        {
794                                {
795                                obsolete = LT(1);
796                                match(OBSOLETE);
797                                et.track("OBSOLETE", obsolete); matchingRule.setObsolete( true );
798                                }
799                                break;
800                        }
801                        case SYNTAX:
802                        {
803                                {
804                                syntax = LT(1);
805                                match(SYNTAX);
806                                et.track("SYNTAX", syntax); matchingRule.setSyntaxOid(numericoid(syntax.getText()));
807                                }
808                                break;
809                        }
810                        case EXTENSION:
811                        {
812                                {
813                                extension = LT(1);
814                                match(EXTENSION);
815                                
816                                Extension ex = extension(extension.getText());
817                                et.track(ex.key, extension); 
818                                matchingRule.addExtension(ex.key, ex.values); 
819                                
820                                }
821                                break;
822                        }
823                        default:
824                        {
825                                break _loop210;
826                        }
827                        }
828                } while (true);
829                }
830                match(RPAR);
831                
832                if( !isQuirksModeEnabled )
833                {    
834                // semantic check: required elements
835                if( !et.contains("SYNTAX") ) {
836                throw new SemanticException( "SYNTAX is required", null, 0, 0 );
837                }
838                }
839                
840                return matchingRule;
841        }
842        
843/**
844     * Production for matching rule use descriptions. It is fault-tolerant
845     * against element ordering.
846     *
847     * <pre>
848     * MatchingRuleUseDescription = LPAREN WSP
849     *    numericoid                 ; object identifier
850     *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
851     *    [ SP "DESC" SP qdstring ]  ; description
852     *    [ SP "OBSOLETE" ]          ; not active
853     *    SP "APPLIES" SP oids       ; attribute types
854     *    extensions WSP RPAREN      ; extensions
855     * </pre>
856    */
857        public final MatchingRuleUse  matchingRuleUseDescription() throws RecognitionException, TokenStreamException {
858                MatchingRuleUse matchingRuleUse;
859                
860                Token  oid = null;
861                Token  name = null;
862                Token  desc = null;
863                Token  obsolete = null;
864                Token  applies = null;
865                Token  extension = null;
866                
867                matchedProduction( "matchingRuleUseDescription()" );
868                ElementTracker et = new ElementTracker();
869                
870                
871                {
872                oid = LT(1);
873                match(STARTNUMERICOID);
874                matchingRuleUse = new MatchingRuleUse(numericoid(oid.getText()));
875                }
876                {
877                _loop219:
878                do {
879                        switch ( LA(1)) {
880                        case NAME:
881                        {
882                                {
883                                name = LT(1);
884                                match(NAME);
885                                et.track("NAME", name); matchingRuleUse.setNames(qdescrs(name.getText()));
886                                }
887                                break;
888                        }
889                        case DESC:
890                        {
891                                {
892                                desc = LT(1);
893                                match(DESC);
894                                et.track("DESC", desc); matchingRuleUse.setDescription(qdstring(desc.getText()));
895                                }
896                                break;
897                        }
898                        case OBSOLETE:
899                        {
900                                {
901                                obsolete = LT(1);
902                                match(OBSOLETE);
903                                et.track("OBSOLETE", obsolete); matchingRuleUse.setObsolete( true );
904                                }
905                                break;
906                        }
907                        case APPLIES:
908                        {
909                                {
910                                applies = LT(1);
911                                match(APPLIES);
912                                et.track("APPLIES", applies); matchingRuleUse.setApplicableAttributeOids(oids(applies.getText()));
913                                }
914                                break;
915                        }
916                        case EXTENSION:
917                        {
918                                {
919                                extension = LT(1);
920                                match(EXTENSION);
921                                
922                                Extension ex = extension(extension.getText());
923                                et.track(ex.key, extension); 
924                                matchingRuleUse.addExtension(ex.key, ex.values); 
925                                
926                                }
927                                break;
928                        }
929                        default:
930                        {
931                                break _loop219;
932                        }
933                        }
934                } while (true);
935                }
936                match(RPAR);
937                
938                if( !isQuirksModeEnabled )
939                {
940                // semantic check: required elements
941                if( !et.contains("APPLIES") ) {
942                throw new SemanticException( "APPLIES is required", null, 0, 0 );
943                }
944                }
945                
946                return matchingRuleUse;
947        }
948        
949/**
950     * Production for DIT content rule descriptions. It is fault-tolerant
951     * against element ordering.
952     *
953     * <pre>
954     * DITContentRuleDescription = LPAREN WSP
955     *    numericoid                 ; object identifier
956     *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
957     *    [ SP "DESC" SP qdstring ]  ; description
958     *    [ SP "OBSOLETE" ]          ; not active
959     *    [ SP "AUX" SP oids ]       ; auxiliary object classes
960     *    [ SP "MUST" SP oids ]      ; attribute types
961     *    [ SP "MAY" SP oids ]       ; attribute types
962     *    [ SP "NOT" SP oids ]       ; attribute types
963     *    extensions WSP RPAREN      ; extensions
964     * </pre>
965    */
966        public final DITContentRule  ditContentRuleDescription() throws RecognitionException, TokenStreamException {
967                DITContentRule ditContentRule;
968                
969                Token  oid = null;
970                Token  name = null;
971                Token  desc = null;
972                Token  obsolete = null;
973                Token  aux = null;
974                Token  must = null;
975                Token  may = null;
976                Token  not = null;
977                Token  extension = null;
978                
979                matchedProduction( "ditContentRuleDescription()" );
980                ElementTracker et = new ElementTracker();
981                
982                
983                {
984                oid = LT(1);
985                match(STARTNUMERICOID);
986                ditContentRule = new DITContentRule(numericoid(oid.getText()));
987                }
988                {
989                _loop231:
990                do {
991                        switch ( LA(1)) {
992                        case NAME:
993                        {
994                                {
995                                name = LT(1);
996                                match(NAME);
997                                et.track("NAME", name); ditContentRule.setNames(qdescrs(name.getText()));
998                                }
999                                break;
1000                        }
1001                        case DESC:
1002                        {
1003                                {
1004                                desc = LT(1);
1005                                match(DESC);
1006                                et.track("DESC", desc); ditContentRule.setDescription(qdstring(desc.getText()));
1007                                }
1008                                break;
1009                        }
1010                        case OBSOLETE:
1011                        {
1012                                {
1013                                obsolete = LT(1);
1014                                match(OBSOLETE);
1015                                et.track("OBSOLETE", obsolete); ditContentRule.setObsolete( true );
1016                                }
1017                                break;
1018                        }
1019                        case AUX:
1020                        {
1021                                {
1022                                aux = LT(1);
1023                                match(AUX);
1024                                et.track("AUX", aux); ditContentRule.setAuxObjectClassOids(oids(aux.getText()));
1025                                }
1026                                break;
1027                        }
1028                        case MUST:
1029                        {
1030                                {
1031                                must = LT(1);
1032                                match(MUST);
1033                                et.track("MUST", must); ditContentRule.setMustAttributeTypeOids(oids(must.getText()));
1034                                }
1035                                break;
1036                        }
1037                        case MAY:
1038                        {
1039                                {
1040                                may = LT(1);
1041                                match(MAY);
1042                                et.track("MAY", may); ditContentRule.setMayAttributeTypeOids(oids(may.getText()));
1043                                }
1044                                break;
1045                        }
1046                        case NOT:
1047                        {
1048                                {
1049                                not = LT(1);
1050                                match(NOT);
1051                                et.track("NOT", not); ditContentRule.setNotAttributeTypeOids(oids(not.getText()));
1052                                }
1053                                break;
1054                        }
1055                        case EXTENSION:
1056                        {
1057                                {
1058                                extension = LT(1);
1059                                match(EXTENSION);
1060                                
1061                                Extension ex = extension(extension.getText());
1062                                et.track(ex.key, extension); 
1063                                ditContentRule.addExtension(ex.key, ex.values); 
1064                                
1065                                }
1066                                break;
1067                        }
1068                        default:
1069                        {
1070                                break _loop231;
1071                        }
1072                        }
1073                } while (true);
1074                }
1075                match(RPAR);
1076                return ditContentRule;
1077        }
1078        
1079/**
1080     * Production for DIT structure rules descriptions. It is fault-tolerant
1081     * against element ordering.
1082     *
1083     * <pre>
1084     * DITStructureRuleDescription = LPAREN WSP
1085     *   ruleid                     ; rule identifier
1086     *   [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
1087     *   [ SP "DESC" SP qdstring ]  ; description
1088     *   [ SP "OBSOLETE" ]          ; not active
1089     *   SP "FORM" SP oid           ; NameForm
1090     *   [ SP "SUP" ruleids ]       ; superior rules
1091     *   extensions WSP RPAREN      ; extensions
1092     *
1093     * ruleids = ruleid / ( LPAREN WSP ruleidlist WSP RPAREN )
1094     * ruleidlist = ruleid *( SP ruleid )
1095     * ruleid = number
1096     * </pre>
1097    */
1098        public final DITStructureRule  ditStructureRuleDescription() throws RecognitionException, TokenStreamException {
1099                DITStructureRule ditStructureRule;
1100                
1101                Token  ruleid = null;
1102                Token  name = null;
1103                Token  desc = null;
1104                Token  obsolete = null;
1105                Token  form = null;
1106                Token  sup = null;
1107                Token  extension = null;
1108                
1109                matchedProduction( "ditStructureRuleDescription()" );
1110                ElementTracker et = new ElementTracker();
1111                
1112                
1113                {
1114                ruleid = LT(1);
1115                match(STARTNUMERICOID);
1116                ditStructureRule = new DITStructureRule(ruleid(ruleid.getText()));
1117                }
1118                {
1119                _loop241:
1120                do {
1121                        switch ( LA(1)) {
1122                        case NAME:
1123                        {
1124                                {
1125                                name = LT(1);
1126                                match(NAME);
1127                                et.track("NAME", name); ditStructureRule.setNames(qdescrs(name.getText()));
1128                                }
1129                                break;
1130                        }
1131                        case DESC:
1132                        {
1133                                {
1134                                desc = LT(1);
1135                                match(DESC);
1136                                et.track("DESC", desc); ditStructureRule.setDescription(qdstring(desc.getText()));
1137                                }
1138                                break;
1139                        }
1140                        case OBSOLETE:
1141                        {
1142                                {
1143                                obsolete = LT(1);
1144                                match(OBSOLETE);
1145                                et.track("OBSOLETE", obsolete); ditStructureRule.setObsolete( true );
1146                                }
1147                                break;
1148                        }
1149                        case FORM:
1150                        {
1151                                {
1152                                form = LT(1);
1153                                match(FORM);
1154                                et.track("FORM", form); ditStructureRule.setForm(oid(form.getText()));
1155                                }
1156                                break;
1157                        }
1158                        case SUP:
1159                        {
1160                                {
1161                                sup = LT(1);
1162                                match(SUP);
1163                                et.track("SUP", sup); ditStructureRule.setSuperRules(ruleids(sup.getText()));
1164                                }
1165                                break;
1166                        }
1167                        case EXTENSION:
1168                        {
1169                                {
1170                                extension = LT(1);
1171                                match(EXTENSION);
1172                                
1173                                Extension ex = extension(extension.getText());
1174                                et.track(ex.key, extension); 
1175                                ditStructureRule.addExtension(ex.key, ex.values); 
1176                                
1177                                }
1178                                break;
1179                        }
1180                        default:
1181                        {
1182                                break _loop241;
1183                        }
1184                        }
1185                } while (true);
1186                }
1187                match(RPAR);
1188                
1189                if( !isQuirksModeEnabled )
1190                {
1191                // semantic check: required elements
1192                if( !et.contains("FORM") ) {
1193                throw new SemanticException( "FORM is required", null, 0, 0 );
1194                }
1195                }
1196                
1197                return ditStructureRule;
1198        }
1199        
1200/**
1201     * Production for name form descriptions. It is fault-tolerant
1202     * against element ordering.
1203     *
1204     * <pre>
1205     * NameFormDescription = LPAREN WSP
1206     *    numericoid                 ; object identifier
1207     *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
1208     *    [ SP "DESC" SP qdstring ]  ; description
1209     *    [ SP "OBSOLETE" ]          ; not active
1210     *    SP "OC" SP oid             ; structural object class
1211     *    SP "MUST" SP oids          ; attribute types
1212     *    [ SP "MAY" SP oids ]       ; attribute types
1213     *    extensions WSP RPAREN      ; extensions
1214     * </pre>
1215    */
1216        public final NameForm  nameFormDescription() throws RecognitionException, TokenStreamException {
1217                NameForm nameForm;
1218                
1219                Token  oid = null;
1220                Token  name = null;
1221                Token  desc = null;
1222                Token  obsolete = null;
1223                Token  oc = null;
1224                Token  must = null;
1225                Token  may = null;
1226                Token  extension = null;
1227                
1228                matchedProduction( "nameFormDescription()" );
1229                ElementTracker et = new ElementTracker();
1230                
1231                
1232                {
1233                oid = LT(1);
1234                match(STARTNUMERICOID);
1235                nameForm = new NameForm(numericoid(oid.getText()));
1236                }
1237                {
1238                _loop252:
1239                do {
1240                        switch ( LA(1)) {
1241                        case NAME:
1242                        {
1243                                {
1244                                name = LT(1);
1245                                match(NAME);
1246                                et.track("NAME", name); nameForm.setNames(qdescrs(name.getText()));
1247                                }
1248                                break;
1249                        }
1250                        case DESC:
1251                        {
1252                                {
1253                                desc = LT(1);
1254                                match(DESC);
1255                                et.track("DESC", desc); nameForm.setDescription(qdstring(desc.getText()));
1256                                }
1257                                break;
1258                        }
1259                        case OBSOLETE:
1260                        {
1261                                {
1262                                obsolete = LT(1);
1263                                match(OBSOLETE);
1264                                et.track("OBSOLETE", obsolete); nameForm.setObsolete( true );
1265                                }
1266                                break;
1267                        }
1268                        case OC:
1269                        {
1270                                {
1271                                oc = LT(1);
1272                                match(OC);
1273                                et.track("OC", oc); nameForm.setStructuralObjectClassOid(oid(oc.getText()));
1274                                }
1275                                break;
1276                        }
1277                        case MUST:
1278                        {
1279                                {
1280                                must = LT(1);
1281                                match(MUST);
1282                                et.track("MUST", must); nameForm.setMustAttributeTypeOids(oids(must.getText()));
1283                                }
1284                                break;
1285                        }
1286                        case MAY:
1287                        {
1288                                {
1289                                may = LT(1);
1290                                match(MAY);
1291                                et.track("MAY", may); nameForm.setMayAttributeTypeOids(oids(may.getText()));
1292                                }
1293                                break;
1294                        }
1295                        case EXTENSION:
1296                        {
1297                                {
1298                                extension = LT(1);
1299                                match(EXTENSION);
1300                                
1301                                Extension ex = extension(extension.getText());
1302                                et.track(ex.key, extension); 
1303                                nameForm.addExtension(ex.key, ex.values); 
1304                                
1305                                }
1306                                break;
1307                        }
1308                        default:
1309                        {
1310                                break _loop252;
1311                        }
1312                        }
1313                } while (true);
1314                }
1315                match(RPAR);
1316                
1317                if( !isQuirksModeEnabled )
1318                {
1319                // semantic check: required elements
1320                if( !et.contains("MUST") ) {
1321                throw new SemanticException( "MUST is required", null, 0, 0 );
1322                }
1323                if( !et.contains("OC") ) {
1324                throw new SemanticException( "OC is required", null, 0, 0 );
1325                }
1326                
1327                // semantic check: MUST and MAY must be disjoint
1328                //List<String> aList = new ArrayList<String>( nfd.getMustAttributeTypes() );
1329                //aList.retainAll( nfd.getMayAttributeTypes() );
1330                //if( !aList.isEmpty() ) 
1331                //{
1332                //    throw new SemanticException( "MUST and MAY must be disjoint, "+aList.get( 0 )+" appears in both", null, 0, 0 );
1333                //}
1334                }
1335                
1336                return nameForm;
1337        }
1338        
1339/**
1340     * Production for comparator descriptions. It is fault-tolerant
1341     * against element ordering.
1342     *
1343     * <pre>
1344     * LdapComparator = LPAREN WSP
1345     *       numericoid                           ; object identifier
1346     *       [ SP "DESC" SP qdstring ]            ; description
1347     *       SP "FQCN" SP fqcn                    ; fully qualified class name
1348     *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
1349     *       extensions WSP RPAREN                ; extensions
1350     * 
1351     * base64          = *(4base64-char)
1352     * base64-char     = ALPHA / DIGIT / "+" / "/"
1353     * fqcn = fqcnComponent 1*( DOT fqcnComponent )
1354     * fqcnComponent = ???
1355     * </pre>
1356    */
1357        public final LdapComparatorDescription  ldapComparator() throws RecognitionException, TokenStreamException {
1358                LdapComparatorDescription lcd;
1359                
1360                Token  oid = null;
1361                Token  desc = null;
1362                Token  fqcn = null;
1363                Token  bytecode = null;
1364                Token  extension = null;
1365                
1366                matchedProduction( "ldapComparator()" );
1367                ElementTracker et = new ElementTracker();
1368                
1369                
1370                {
1371                oid = LT(1);
1372                match(STARTNUMERICOID);
1373                lcd = new LdapComparatorDescription(numericoid(oid.getText()));
1374                }
1375                {
1376                _loop260:
1377                do {
1378                        switch ( LA(1)) {
1379                        case DESC:
1380                        {
1381                                {
1382                                desc = LT(1);
1383                                match(DESC);
1384                                et.track("DESC", desc); lcd.setDescription(qdstring(desc.getText()));
1385                                }
1386                                break;
1387                        }
1388                        case FQCN:
1389                        {
1390                                {
1391                                fqcn = LT(1);
1392                                match(FQCN);
1393                                et.track("FQCN", fqcn); lcd.setFqcn(fqcn.getText());
1394                                }
1395                                break;
1396                        }
1397                        case BYTECODE:
1398                        {
1399                                {
1400                                bytecode = LT(1);
1401                                match(BYTECODE);
1402                                et.track("BYTECODE", bytecode); lcd.setBytecode(bytecode.getText());
1403                                }
1404                                break;
1405                        }
1406                        case EXTENSION:
1407                        {
1408                                {
1409                                extension = LT(1);
1410                                match(EXTENSION);
1411                                
1412                                Extension ex = extension(extension.getText());
1413                                et.track(ex.key, extension); 
1414                                lcd.addExtension(ex.key, ex.values); 
1415                                
1416                                }
1417                                break;
1418                        }
1419                        default:
1420                        {
1421                                break _loop260;
1422                        }
1423                        }
1424                } while (true);
1425                }
1426                match(RPAR);
1427                
1428                if( !isQuirksModeEnabled )
1429                {
1430                // semantic check: required elements
1431                if( !et.contains("FQCN") ) {
1432                throw new SemanticException( "FQCN is required", null, 0, 0 );
1433                }
1434                
1435                // semantic check: length should be divisible by 4
1436                if( ( lcd.getBytecode() != null ) && ( lcd.getBytecode().length() % 4 != 0 ) ) {
1437                throw new SemanticException( "BYTECODE must be divisible by 4", null, 0, 0 );
1438                }
1439                }
1440                
1441                return lcd;
1442        }
1443        
1444/**
1445     * Production for normalizer descriptions. It is fault-tolerant
1446     * against element ordering.
1447     *
1448     * <pre>
1449     * NormalizerDescription = LPAREN WSP
1450     *       numericoid                           ; object identifier
1451     *       [ SP "DESC" SP qdstring ]            ; description
1452     *       SP "FQCN" SP fqcn                    ; fully qualified class name
1453     *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
1454     *       extensions WSP RPAREN                ; extensions
1455     * 
1456     * base64          = *(4base64-char)
1457     * base64-char     = ALPHA / DIGIT / "+" / "/"
1458     * fqcn = fqcnComponent 1*( DOT fqcnComponent )
1459     * fqcnComponent = ???
1460     * </pre>
1461    */
1462        public final NormalizerDescription  normalizerDescription() throws RecognitionException, TokenStreamException {
1463                NormalizerDescription nd;
1464                
1465                Token  oid = null;
1466                Token  desc = null;
1467                Token  fqcn = null;
1468                Token  bytecode = null;
1469                Token  extension = null;
1470                
1471                matchedProduction( "normalizerDescription()" );
1472                ElementTracker et = new ElementTracker();
1473                
1474                
1475                {
1476                oid = LT(1);
1477                match(STARTNUMERICOID);
1478                nd = new NormalizerDescription(numericoid(oid.getText()));
1479                }
1480                {
1481                _loop268:
1482                do {
1483                        switch ( LA(1)) {
1484                        case DESC:
1485                        {
1486                                {
1487                                desc = LT(1);
1488                                match(DESC);
1489                                et.track("DESC", desc); nd.setDescription(qdstring(desc.getText()));
1490                                }
1491                                break;
1492                        }
1493                        case FQCN:
1494                        {
1495                                {
1496                                fqcn = LT(1);
1497                                match(FQCN);
1498                                et.track("FQCN", fqcn); nd.setFqcn(fqcn.getText());
1499                                }
1500                                break;
1501                        }
1502                        case BYTECODE:
1503                        {
1504                                {
1505                                bytecode = LT(1);
1506                                match(BYTECODE);
1507                                et.track("BYTECODE", bytecode); nd.setBytecode(bytecode.getText());
1508                                }
1509                                break;
1510                        }
1511                        case EXTENSION:
1512                        {
1513                                {
1514                                extension = LT(1);
1515                                match(EXTENSION);
1516                                
1517                                Extension ex = extension(extension.getText());
1518                                et.track(ex.key, extension); 
1519                                nd.addExtension(ex.key, ex.values); 
1520                                
1521                                }
1522                                break;
1523                        }
1524                        default:
1525                        {
1526                                break _loop268;
1527                        }
1528                        }
1529                } while (true);
1530                }
1531                match(RPAR);
1532                
1533                if( !isQuirksModeEnabled )
1534                {
1535                // semantic check: required elements
1536                if( !et.contains("FQCN") ) {
1537                throw new SemanticException( "FQCN is required", null, 0, 0 );
1538                }
1539                
1540                // semantic check: length should be divisible by 4
1541                if( nd.getBytecode() != null && ( nd.getBytecode().length() % 4 != 0 ) ) {
1542                throw new SemanticException( "BYTECODE must be divisible by 4", null, 0, 0 );
1543                }     
1544                }   
1545                
1546                return nd;
1547        }
1548        
1549/**
1550     * Production for syntax checker descriptions. It is fault-tolerant
1551     * against element ordering.
1552     *
1553     * <pre>
1554     * SyntaxCheckerDescription = LPAREN WSP
1555     *       numericoid                           ; object identifier
1556     *       [ SP "DESC" SP qdstring ]            ; description
1557     *       SP "FQCN" SP fqcn                    ; fully qualified class name
1558     *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
1559     *       extensions WSP RPAREN                ; extensions
1560     * 
1561     * base64          = *(4base64-char)
1562     * base64-char     = ALPHA / DIGIT / "+" / "/"
1563     * fqcn = fqcnComponent 1*( DOT fqcnComponent )
1564     * fqcnComponent = ???
1565     * </pre>
1566    */
1567        public final SyntaxCheckerDescription  syntaxCheckerDescription() throws RecognitionException, TokenStreamException {
1568                SyntaxCheckerDescription scd;
1569                
1570                Token  oid = null;
1571                Token  desc = null;
1572                Token  fqcn = null;
1573                Token  bytecode = null;
1574                Token  extension = null;
1575                
1576                matchedProduction( "syntaxCheckerDescription()" );
1577                ElementTracker et = new ElementTracker();
1578                
1579                
1580                {
1581                oid = LT(1);
1582                match(STARTNUMERICOID);
1583                scd = new SyntaxCheckerDescription(numericoid(oid.getText()));
1584                }
1585                {
1586                _loop276:
1587                do {
1588                        switch ( LA(1)) {
1589                        case DESC:
1590                        {
1591                                {
1592                                desc = LT(1);
1593                                match(DESC);
1594                                et.track("DESC", desc); scd.setDescription(qdstring(desc.getText()));
1595                                }
1596                                break;
1597                        }
1598                        case FQCN:
1599                        {
1600                                {
1601                                fqcn = LT(1);
1602                                match(FQCN);
1603                                et.track("FQCN", fqcn); scd.setFqcn(fqcn.getText());
1604                                }
1605                                break;
1606                        }
1607                        case BYTECODE:
1608                        {
1609                                {
1610                                bytecode = LT(1);
1611                                match(BYTECODE);
1612                                et.track("BYTECODE", bytecode); scd.setBytecode(bytecode.getText());
1613                                }
1614                                break;
1615                        }
1616                        case EXTENSION:
1617                        {
1618                                {
1619                                extension = LT(1);
1620                                match(EXTENSION);
1621                                
1622                                Extension ex = extension(extension.getText());
1623                                et.track(ex.key, extension); 
1624                                scd.addExtension(ex.key, ex.values); 
1625                                
1626                                }
1627                                break;
1628                        }
1629                        default:
1630                        {
1631                                break _loop276;
1632                        }
1633                        }
1634                } while (true);
1635                }
1636                match(RPAR);
1637                
1638                if( !isQuirksModeEnabled )
1639                {
1640                // semantic check: required elements
1641                if( !et.contains("FQCN") ) {
1642                throw new SemanticException( "FQCN is required", null, 0, 0 );
1643                }
1644                
1645                // semantic check: length should be divisible by 4
1646                if( scd.getBytecode() != null && ( scd.getBytecode().length() % 4 != 0 ) ) {
1647                throw new SemanticException( "BYTECODE must be divisible by 4", null, 0, 0 );
1648                }  
1649                }      
1650                
1651                return scd;
1652        }
1653        
1654        public final NoidLen  noidlen(
1655                String s
1656        ) throws RecognitionException, TokenStreamException {
1657                NoidLen noidlen;
1658                
1659                
1660                matchedProduction( "noidlen()" );
1661                AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s));
1662                AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer);
1663                parser.setParserMonitor(monitor);
1664                noidlen = isQuirksModeEnabled ? parser.quirksNoidlen() : parser.noidlen();
1665                
1666                
1667                return noidlen;
1668        }
1669        
1670        public final Extension  extension(
1671                String s
1672        ) throws RecognitionException, TokenStreamException {
1673                Extension extension;
1674                
1675                
1676                matchedProduction( "extension()" );
1677                AntlrSchemaExtensionLexer lexer = new AntlrSchemaExtensionLexer(new StringReader(s));
1678                AntlrSchemaExtensionParser parser = new AntlrSchemaExtensionParser(lexer);
1679                extension = parser.extension();
1680                
1681                
1682                return extension;
1683        }
1684        
1685        public final String  numericoid(
1686                String s
1687        ) throws RecognitionException, TokenStreamException {
1688                String numericoid;
1689                
1690                
1691                matchedProduction( "numericoid()");
1692                if(isQuirksModeEnabled)
1693                {
1694                numericoid = oid(s);
1695                }
1696                else
1697                {
1698                                AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s));
1699                                AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer);
1700                                parser.setParserMonitor(monitor);
1701                                numericoid = parser.numericoid();
1702                }
1703                
1704                
1705                return numericoid;
1706        }
1707        
1708        public final String  oid(
1709                String s
1710        ) throws RecognitionException, TokenStreamException {
1711                String oid;
1712                
1713                
1714                matchedProduction( "oid()" );
1715                List<String> oids = oids(s);
1716                if( oids.size() != 1 ) 
1717                {
1718                throw new SemanticException( "Exactly one OID expected", null, 0, 0 );
1719                }
1720                oid = oids.get(0);
1721                
1722                
1723                return oid;
1724        }
1725        
1726        public final List<String>  oids(
1727                String s
1728        ) throws RecognitionException, TokenStreamException {
1729                List<String> oids;
1730                
1731                
1732                matchedProduction( "oids()" );
1733                if(isQuirksModeEnabled)
1734                {
1735                oids = qdescrs(s);
1736                }
1737                else
1738                {
1739                                AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s));
1740                                AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer);
1741                                parser.setParserMonitor(monitor);
1742                                oids = parser.oids();
1743                            }
1744                
1745                
1746                return oids;
1747        }
1748        
1749        public final String  qdescr(
1750                String s
1751        ) throws RecognitionException, TokenStreamException {
1752                String qdescr;
1753                
1754                
1755                matchedProduction( "qdescr()" );
1756                List<String> qdescrs = qdescrs(s);
1757                if( qdescrs.size() != 1 ) 
1758                {
1759                throw new SemanticException( "Exactly one qdescrs expected", null, 0, 0 );
1760                }
1761                qdescr = qdescrs.get(0);
1762                
1763                
1764                return qdescr;
1765        }
1766        
1767        public final List<String>  qdescrs(
1768                String s
1769        ) throws RecognitionException, TokenStreamException {
1770                List<String> qdescrs;
1771                
1772                
1773                matchedProduction( "qdescrs()" );
1774                AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s));
1775                AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer);
1776                parser.setParserMonitor(monitor);
1777                qdescrs = isQuirksModeEnabled ? parser.quirksQdescrs() : parser.qdescrs();
1778                
1779                
1780                return qdescrs;
1781        }
1782        
1783        public final String  qdstring(
1784                String s
1785        ) throws RecognitionException, TokenStreamException {
1786                String qdstring;
1787                
1788                
1789                matchedProduction( "qdstring()" );
1790                List<String> qdstrings = qdstrings(s);
1791                if( qdstrings.size() != 1 ) 
1792                {
1793                throw new SemanticException( "Exactly one qdstrings expected", null, 0, 0 );
1794                }
1795                qdstring = qdstrings.get(0);
1796                
1797                
1798                return qdstring;
1799        }
1800        
1801        public final List<String>  qdstrings(
1802                String s
1803        ) throws RecognitionException, TokenStreamException {
1804                List<String> qdstrings;
1805                
1806                
1807                matchedProduction( "qdstrings()" );
1808                AntlrSchemaQdstringLexer lexer = new AntlrSchemaQdstringLexer(new StringReader(s));
1809                AntlrSchemaQdstringParser parser = new AntlrSchemaQdstringParser(lexer);
1810                parser.setParserMonitor(monitor);
1811                qdstrings = parser.qdstrings();
1812                
1813                
1814                return qdstrings;
1815        }
1816        
1817        public final Integer  ruleid(
1818                String s
1819        ) throws RecognitionException, TokenStreamException {
1820                Integer ruleid;
1821                
1822                
1823                matchedProduction( "ruleid()" );
1824                AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s));
1825                AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer);
1826                parser.setParserMonitor(monitor);
1827                ruleid = parser.ruleid();
1828                
1829                
1830                return ruleid;
1831        }
1832        
1833        public final List<Integer>  ruleids(
1834                String s
1835        ) throws RecognitionException, TokenStreamException {
1836                List<Integer> ruleids;
1837                
1838                
1839                matchedProduction( "ruleids()" );
1840                AntlrSchemaValueLexer lexer = new AntlrSchemaValueLexer(new StringReader(s));
1841                AntlrSchemaValueParser parser = new AntlrSchemaValueParser(lexer);
1842                parser.setParserMonitor(monitor);
1843                ruleids = parser.ruleids();
1844                
1845                
1846                return ruleids;
1847        }
1848        
1849        
1850        public static final String[] _tokenNames = {
1851                "<0>",
1852                "EOF",
1853                "<2>",
1854                "NULL_TREE_LOOKAHEAD",
1855                "WHSP",
1856                "LPAR",
1857                "RPAR",
1858                "QUOTE",
1859                "DOLLAR",
1860                "LBRACKET",
1861                "RBRACKET",
1862                "LEN",
1863                "SINGLE_VALUE",
1864                "COLLECTIVE",
1865                "NO_USER_MODIFICATION",
1866                "OBSOLETE",
1867                "ABSTRACT",
1868                "STRUCTURAL",
1869                "AUXILIARY",
1870                "OBJECTIDENTIFIER",
1871                "OBJECTCLASS",
1872                "ATTRIBUTETYPE",
1873                "STARTNUMERICOID",
1874                "NAME",
1875                "DESC",
1876                "SUP",
1877                "MUST",
1878                "MAY",
1879                "AUX",
1880                "NOT",
1881                "FORM",
1882                "OC",
1883                "EQUALITY",
1884                "ORDERING",
1885                "SUBSTR",
1886                "SYNTAX",
1887                "APPLIES",
1888                "EXTENSION",
1889                "FQCN",
1890                "BYTECODE",
1891                "AUX_OR_AUXILIARY",
1892                "VALUES",
1893                "VALUE",
1894                "UNQUOTED_STRING",
1895                "QUOTED_STRING",
1896                "FQCN_VALUE",
1897                "FQCN_IDENTIFIER",
1898                "FQCN_LETTER",
1899                "FQCN_LETTERORDIGIT",
1900                "BYTECODE_VALUE",
1901                "USAGE",
1902                "USER_APPLICATIONS",
1903                "DIRECTORY_OPERATION",
1904                "DISTRIBUTED_OPERATION",
1905                "DSA_OPERATION"
1906        };
1907        
1908        
1909        }