/*
    *  Licensed to the Apache Software Foundation (ASF) under one
    *  or more contributor license agreements.  See the NOTICE file
    *  distributed with this work for additional information
    *  regarding copyright ownership.  The ASF licenses this file
    *  to you under the Apache License, Version 2.0 (the
    *  "License"); you may not use this file except in compliance
    *  with the License.  You may obtain a copy of the License at
    * 
   *    https://www.apache.org/licenses/LICENSE-2.0
   * 
   *  Unless required by applicable law or agreed to in writing,
   *  software distributed under the License is distributed on an
   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   *  KIND, either express or implied.  See the License for the
   *  specific language governing permissions and limitations
   *  under the License.
   * 
   */
  package org.apache.directory.api.ldap.model.schema.parsers;
  
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.Reader;
  import java.io.StringReader;
  import java.nio.charset.Charset;
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.text.ParseException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.directory.api.asn1.util.Oid;
  import org.apache.directory.api.i18n.I18n;
  import org.apache.directory.api.ldap.model.exception.LdapSchemaException;
  import org.apache.directory.api.ldap.model.schema.AttributeType;
  import org.apache.directory.api.ldap.model.schema.DitContentRule;
  import org.apache.directory.api.ldap.model.schema.DitStructureRule;
  import org.apache.directory.api.ldap.model.schema.LdapSyntax;
  import org.apache.directory.api.ldap.model.schema.MatchingRule;
  import org.apache.directory.api.ldap.model.schema.MatchingRuleUse;
  import org.apache.directory.api.ldap.model.schema.ObjectClass;
  import org.apache.directory.api.ldap.model.schema.NameForm;
  import org.apache.directory.api.ldap.model.schema.ObjectClassTypeEnum;
  import org.apache.directory.api.ldap.model.schema.SchemaObject;
  import org.apache.directory.api.ldap.model.schema.UsageEnum;
  import org.apache.directory.api.ldap.model.schema.syntaxCheckers.OpenLdapObjectIdentifierMacro;
  import org.apache.directory.api.util.Strings;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * A reusable wrapper for hand parser OpenLDAP schema.
   *
   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
   */
  public class OpenLdapSchemaParser
  {
      /** The LoggerFactory used by this class */
      protected static final Logger LOG = LoggerFactory.getLogger( OpenLdapSchemaParser.class );
  
      /** A flag used to tell the parser if it should be strict or not */
      private boolean isQuirksModeEnabled = false;
  
      /** the number of the current line being parsed by the reader */
      protected int lineNumber;
  
      /** The list of parsed schema descriptions */
      private List<Object> schemaDescriptions = new ArrayList<>();
  
      /** The list of attribute type, initialized by splitParsedSchemaDescriptions() */
      private List<AttributeType> attributeTypes;
  
      /** The list of object classes, initialized by splitParsedSchemaDescriptions()*/
      private List<ObjectClass> objectClasses;
  
      /** The map of object identifier macros, initialized by splitParsedSchemaDescriptions()*/
      private Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros = new HashMap<>();
      
      /** Some contant strings used in descriptions */
      private static final String APPLIES_STR                 = "APPLIES";
      private static final String ABSTRACT_STR                = "ABSTRACT";
      private static final String AUX_STR                     = "AUX";
      private static final String AUXILIARY_STR               = "AUXILIARY";
      private static final String BYTECODE_STR                = "BYTECODE";
      private static final String COLLECTIVE_STR              = "COLLECTIVE";
      private static final String DESC_STR                    = "DESC";
      private static final String EQUALITY_STR                = "EQUALITY";
      private static final String FORM_STR                    = "FORM";
      private static final String FQCN_STR                    = "FQCN";
      private static final String MAY_STR                     = "MAY";
      private static final String MUST_STR                    = "MUST";
      private static final String NAME_STR                    = "NAME";
     private static final String NO_USER_MODIFICATION_STR    = "NO-USER-MODIFICATION";
     private static final String NOT_STR                     = "NOT";
     private static final String OBSOLETE_STR                = "OBSOLETE";
     private static final String OC_STR                      = "OC";
     private static final String ORDERING_STR                = "ORDERING";
     private static final String SINGLE_VALUE_STR            = "SINGLE-VALUE";
     private static final String STRUCTURAL_STR              = "STRUCTURAL";
     private static final String SUBSTR_STR                  = "SUBSTR";
     private static final String SUP_STR                     = "SUP";
     private static final String SYNTAX_STR                  = "SYNTAX";
     private static final String USAGE_STR                   = "USAGE";
     private static final String EXTENSION_PREFIX            = "X-";
     
     /** Usage */
     private static final String DIRECTORY_OPERATION_STR     = "directoryOperation";
     private static final String DISTRIBUTED_OPERATION_STR   = "distributedOperation";
     private static final String DSA_OPERATION_STR           = "dSAOperation";
     private static final String USER_APPLICATIONS_STR       = "userApplications";
 
     /** Tokens */
     private static final char COLON         = ':';
     private static final char DOLLAR        = '$';
     private static final char DOT           = '.';
     private static final char EQUAL         = '=';
     private static final char ESCAPE        = '\\';
     private static final char HYPHEN        = '-';
     private static final char LBRACE        = '{';
     private static final char LPAREN        = '(';
     private static final char PLUS          = '+';
     private static final char RBRACE        = '}';
     private static final char RPAREN        = ')';
     private static final char SEMI_COLON    = ';';
     private static final char SHARP         = '#';
     private static final char SLASH         = '/';
     private static final char SQUOTE        = '\'';
     private static final char UNDERSCORE    = '_';
     private static final char DQUOTE        = '"';
 
 
     /** Flag whether object identifier macros should be resolved. */
     private boolean isResolveObjectIdentifierMacros;
     
     private static final boolean UN_QUOTED = false;
     
     /** Flag for strict or relaxed mode */
     private static final boolean STRICT = false;
     private static final boolean RELAXED = true;
     
     private class PosSchema
     {
         /** The line number in the file */
         int lineNumber;
         
         /** The position in the current line */
         int start;
         
         /** The line being processed */
         String line;
         
         /**
          * {@inheritDoc} 
          */
         @Override
         public String toString()
         {
             if ( line == null )
             {
                 return "null";
             }
             else if ( line.length() < start )
             {
                 return "EOL";
             }
             else
             {
                 return line.substring( start ); 
             }
         }
     }
 
 
     private interface SchemaObjectElements
     {
         int getValue();
     }
 
     
     /**
      * The list of AttributeTypeDescription elements that can be seen 
      */
     private enum AttributeTypeElements implements SchemaObjectElements
     {
         NAME(1),
         DESC(2),
         OBSOLETE(4),
         SUP(8),
         EQUALITY(16),
         ORDERING(32),
         SUBSTR(64),
         SYNTAX(128),
         SINGLE_VALUE(256),
         COLLECTIVE(512),
         NO_USER_MODIFICATION(1024),
         USAGE(2048);
         
         private int value;
         
         AttributeTypeElements( int value )
         {
             this.value = value;
         }
         
         
         public int getValue()
         {
             return value;
         }
     }
     
     
     /**
      * The list of DitContentRuleDescription elements that can be seen 
      */
     private enum DitContentRuleElements implements SchemaObjectElements
     {
         NAME(1),
         DESC(2),
         OBSOLETE(4),
         AUX(8),
         MUST(16),
         MAY(32),
         NOT(64);
         
         private int value;
         
         DitContentRuleElements( int value )
         {
             this.value = value;
         }
         
         
         public int getValue()
         {
             return value;
         }
     }
 
 
     /**
      * The list of DitStructureRuleDescription elements that can be seen 
      */
     private enum DitStructureRuleElements implements SchemaObjectElements
     {
         NAME(1),
         DESC(2),
         OBSOLETE(4),
         FORM(8),
         SUP(16);
         
         private int value;
         
         DitStructureRuleElements( int value )
         {
             this.value = value;
         }
         
         
         public int getValue()
         {
             return value;
         }
     }
 
     
     /**
      * The list of LdapComparatorDescription elements that can be seen 
      */
     private enum LdapComparatorElements implements SchemaObjectElements
     {
         DESC(1),
         FQCN(2),
         BYTECODE(4);
         
         private int value;
         
         LdapComparatorElements( int value )
         {
             this.value = value;
         }
         
         
         public int getValue()
         {
             return value;
         }
     }
 
     
     /**
      * The list of LdapSyntaxDescription elements that can be seen 
      */
     private enum LdapSyntaxElements implements SchemaObjectElements
     {
         DESC(1);
         
         private int value;
         
         LdapSyntaxElements( int value )
         {
             this.value = value;
         }
         
         
         public int getValue()
         {
             return value;
         }
     }
 
 
     /**
      * The list of MatchingRuleDescription elements that can be seen 
      */
     private enum MatchingRuleElements implements SchemaObjectElements
     {
         NAME(1),
         DESC(2),
         OBSOLETE(4),
         SYNTAX(8);
         
         private int value;
         
         MatchingRuleElements( int value )
         {
             this.value = value;
         }
         
         
         public int getValue()
         {
             return value;
         }
     }
 
     
     /**
      * The list of MatchingRuleUseDescription elements that can be seen 
      */
     private enum MatchingRuleUseElements implements SchemaObjectElements
     {
         NAME(1),
         DESC(2),
         OBSOLETE(4),
         APPLIES(8);
         
         private int value;
         
         MatchingRuleUseElements( int value )
         {
             this.value = value;
         }
         
         
         public int getValue()
         {
             return value;
         }
     }
 
     
     /**
      * The list of NameFormDescription elements that can be seen 
      */
     private enum NameFormElements implements SchemaObjectElements
     {
         NAME(1),
         DESC(2),
         OBSOLETE(4),
         OC(8),
         MUST(16),
         MAY(32);
         
         private int value;
         
         NameFormElements( int value )
         {
             this.value = value;
         }
         
         
         public int getValue()
         {
             return value;
         }
     }
 
 
     /**
      * The list of NormalizerDescription elements that can be seen 
      */
     private enum NormalizerElements implements SchemaObjectElements
     {
         DESC(1),
         FQCN(2),
         BYTECODE(4);
         
         private int value;
         
         NormalizerElements( int value )
         {
             this.value = value;
         }
         
         
         public int getValue()
         {
             return value;
         }
     }
 
 
     /**
      * The list of ObjectClassDescription elements that can be seen 
      */
     private enum ObjectClassElements implements SchemaObjectElements
     {
         NAME(1),
         DESC(2),
         OBSOLETE(4),
         SUP(8),
         MUST(16),
         MAY(32),
         ABSTRACT(64),
         STRUCTURAL(64),
         AUXILIARY(64);
         
         private int value;
         
         ObjectClassElements( int value )
         {
             this.value = value;
         }
         
         
         public int getValue()
         {
             return value;
         }
     }
 
 
     /**
      * The list of SyntaxCheckerDescription elements that can be seen 
      */
     private enum SyntaxCheckerElements implements SchemaObjectElements
     {
         DESC(1),
         FQCN(2),
         BYTECODE(4);
         
         private int value;
         
         SyntaxCheckerElements( int value )
         {
             this.value = value;
         }
         
         
         public int getValue()
         {
             return value;
         }
     }
 
 
     /**
      * Creates a reusable instance of an OpenLdapSchemaParser.
      */
     public OpenLdapSchemaParser()
     {
         isResolveObjectIdentifierMacros = true;
         isQuirksModeEnabled = false;
     }
 
 
     /**
      * Reset the parser
      */
     public void clear()
     {
         if ( attributeTypes != null )
         {
             attributeTypes.clear();
         }
         
         if ( objectClasses != null )
         {
             objectClasses.clear();
         }
         
         if ( schemaDescriptions != null )
         {
             schemaDescriptions.clear();
         }
     
         if ( objectIdentifierMacros != null )
         {
             objectIdentifierMacros.clear();
         }
     }
 
 
     /**
      * Gets the attribute types.
      * 
      * @return the attribute types
      */
     public List<AttributeType> getAttributeTypes()
     {
         return attributeTypes;
     }
 
 
     /**
      * Gets the object class types.
      * 
      * @return the object class types
      */
     public List<ObjectClass> getObjectClasses()
     {
         return objectClasses;
     }
 
 
     /**
      * Gets the object identifier macros.
      * 
      * @return the object identifier macros
      */
     public Map<String, OpenLdapObjectIdentifierMacro> getObjectIdentifierMacros()
     {
         return objectIdentifierMacros;
     }
 
 
     /**
      * Splits parsed schema descriptions and resolved
      * object identifier macros.
      * 
      * @throws ParseException the parse exception
      */
     private void afterParse() throws ParseException
     {
         objectClasses = new ArrayList<>();
         attributeTypes = new ArrayList<>();
 
         // split parsed schema descriptions
         for ( Object obj : schemaDescriptions )
         {
             if ( obj instanceof OpenLdapObjectIdentifierMacro )
             {
                 OpenLdapObjectIdentifierMacro oid = ( OpenLdapObjectIdentifierMacro ) obj;
                 objectIdentifierMacros.put( oid.getName(), oid );
             }
             else if ( obj instanceof AttributeType )
             {
                 AttributeType attributeType = ( AttributeType ) obj;
 
                 attributeTypes.add( attributeType );
             }
             else if ( obj instanceof ObjectClass )
             {
                 ObjectClass objectClass = ( ObjectClass ) obj;
 
                 objectClasses.add( objectClass );
             }
         }
 
         if ( isResolveObjectIdentifierMacros() )
         {
             // resolve object identifier macros
             for ( OpenLdapObjectIdentifierMacro oid : objectIdentifierMacros.values() )
             {
                 resolveObjectIdentifierMacro( oid );
             }
 
             // apply object identifier macros to object classes
             for ( ObjectClass objectClass : objectClasses )
             {
                 objectClass.setOid( getResolveOid( objectClass.getOid() ) );
             }
 
             // apply object identifier macros to attribute types
             for ( AttributeType attributeType : attributeTypes )
             {
                 attributeType.setOid( getResolveOid( attributeType.getOid() ) );
                 attributeType.setSyntaxOid( getResolveOid( attributeType.getSyntaxOid() ) );
             }
 
         }
     }
 
 
     /**
      * Return a complete OID from a macro followed by an OID.
      * 
      * @param oid The OID to find
      * @return The extended OID
      */
     private String getResolveOid( String oid )
     {
         if ( oid != null && oid.indexOf( COLON ) != -1 )
         {
             // resolve OID
             String[] nameAndSuffix = oid.split( ":" );
             
             if ( objectIdentifierMacros.containsKey( nameAndSuffix[0] ) )
             {
                 OpenLdapObjectIdentifierMacro macro = objectIdentifierMacros.get( nameAndSuffix[0] );
                 
                 return macro.getResolvedOid() + "." + nameAndSuffix[1];
             }
         }
         
         return oid;
     }
 
 
     /**
      * Find the proper OID from a OID which may contain a macro
      * 
      * @param macro The element to resolve
      * @throws ParseException If teh OID is invalid
      */
     private void resolveObjectIdentifierMacro( OpenLdapObjectIdentifierMacro macro ) throws ParseException
     {
         String rawOidOrNameSuffix = macro.getRawOidOrNameSuffix();
 
         if ( !macro.isResolved() )
         {
             if ( rawOidOrNameSuffix.indexOf( COLON ) != -1 )
             {
                 // resolve OID
                 String[] nameAndSuffix = rawOidOrNameSuffix.split( ":" );
                 
                 if ( objectIdentifierMacros.containsKey( nameAndSuffix[0] ) )
                 {
                     OpenLdapObjectIdentifierMacro parentMacro = objectIdentifierMacros.get( nameAndSuffix[0] );
                     resolveObjectIdentifierMacro( parentMacro );
                     macro.setResolvedOid( parentMacro.getResolvedOid() + "." + nameAndSuffix[1] );
                 }
                 else
                 {
                     throw new ParseException( I18n.err( I18n.ERR_13726_NO_OBJECT_IDENTIFIER_MACRO, nameAndSuffix[0] ), 0 );
                 }
             }
             else
             {
                 // no :suffix,
                 if ( objectIdentifierMacros.containsKey( rawOidOrNameSuffix ) )
                 {
                     OpenLdapObjectIdentifierMacro parentMacro = objectIdentifierMacros.get( rawOidOrNameSuffix );
                     resolveObjectIdentifierMacro( parentMacro );
                     macro.setResolvedOid( parentMacro.getResolvedOid() );
                 }
                 else
                 {
                     macro.setResolvedOid( rawOidOrNameSuffix );
                 }
             }
         }
     }
 
 
     /**
      * Parses an OpenLDAP schemaObject element/object.
      *
      * @param schemaObject the String image of a complete schema object
      * @return the schema object
      * @throws ParseException If the schemaObject can't be parsed
      */
     public SchemaObject parse( String schemaObject ) throws ParseException
     {
         if ( ( schemaObject == null ) || Strings.isEmpty( schemaObject.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( schemaObject ) ) )
         {
             parse( reader );
             afterParse();
         }
         catch ( IOException | LdapSchemaException e )
         {
             throw new ParseException( e.getMessage(), 0 );
         }
 
         if ( !schemaDescriptions.isEmpty() )
         {
             for ( Object obj : schemaDescriptions )
             {
                 if ( obj instanceof SchemaObject )
                 {
                     return ( SchemaObject ) obj;
                 }
             }
         }
         
         return null;
     }
 
 
     /**
      * Parses a stream of OpenLDAP schemaObject elements/objects. Default charset is used.
      *
      * @param schemaIn a stream of schema objects
      * @throws ParseException  If the schema can't be parsed
      * @throws LdapSchemaException If there is an error in the schema
      * @throws IOException If the stream can't be read
      */
     public void parse( InputStream schemaIn ) throws ParseException, LdapSchemaException, IOException
     {
         try ( InputStreamReader in = new InputStreamReader( schemaIn, Charset.defaultCharset() ) )
         {
             try ( Reader reader = new BufferedReader( in ) )
             {
                 parse( reader );
                 afterParse();
             }
         }
     }
     
     
     /**
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param mandatory If the spaces are mandatory
      * @throws IOException If the stream can't be read
      * @throws LdapSchemaException If the schema is wrong
      */
     private static void skipWhites( Reader reader, PosSchema pos, boolean mandatory ) throws IOException, LdapSchemaException
     {
         boolean hasSpace = false;
         
         while ( true )
         {
             if ( isEmpty( pos ) )
             {
                 getLine( reader, pos );
                 
                 if ( pos.line == null )
                 {
                     return;
                 }
                 
                 hasSpace = true;
                 continue;
             }
             
             if ( pos.line == null )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13782_END_OF_FILE, pos.lineNumber, pos.start ) );
             }
             
             while ( Character.isWhitespace( pos.line.charAt( pos.start ) ) )
             {
                 hasSpace = true;
                 pos.start++;
                 
                 if ( isEmpty( pos ) )
                 {
                     getLine( reader, pos );
 
                     if ( pos.line == null )
                     {
                         return;
                     }
                 }
             }
             
             if ( pos.line.charAt( pos.start ) == SHARP )
             {
                 getLine( reader, pos );
 
                 if ( pos.line == null )
                 {
                     return;
                 }
                 
                 hasSpace = true;
             }
             else
             {
                 if ( mandatory && !hasSpace )
                 {
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13783_SPACE_EXPECTED, pos.lineNumber, pos.start ) );
                 }
                 else
                 {
                     return;
                 }
             }
         }
     }
     
     
     /**
      * @param pos The position in the Schema
      * @return <tt>true</tt> if this is a comment
      */
     private static boolean isComment( PosSchema pos )
     {
         if ( isEmpty( pos ) )
         {
             return true;
         }
         
         return pos.line.charAt( pos.start ) == SHARP;
     }
     
     
     /**
      * @param pos The position in the Schema
      * @return <tt>true</tt> of the line is empty
      */
     private static boolean isEmpty( PosSchema pos )
     {
         return ( pos.line == null ) || ( pos.start >= pos.line.length() );
     }
     
     
     /**
      * @param pos The position in the Schema
      * @param text The text to find at the beginning of the line
      * @return <tt>true</tt> if teh line starts with the given text
      */
     private static boolean startsWith( PosSchema pos, String text )
     {
         if ( ( pos.line == null ) || ( pos.line.length() - pos.start < text.length() ) )
         {
             return false;
         }
         
         return text.equalsIgnoreCase( pos.line.substring( pos.start, pos.start + text.length() ) );
     }
     
     
     /**
      * Check if the stream starts with a given char at a given position
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param c The char to check
      * @return <tt>true</tT> if the stream starts with the given char at the given position
      * @throws IOException If we can't read the stream
      * @throws LdapSchemaException If we have no char to read
      */
     private static boolean startsWith( Reader reader, PosSchema pos, char c ) throws IOException, LdapSchemaException
     {
         return startsWith( reader, pos, c, UN_QUOTED );
     }
     
 
     /**
      * Check if the stream at the given position starts with a given char
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param c The char to check
      * @param quoted <tt>true</tt> if the char is quoted
      * @return <tt>true</tt> if the stream starts with the given char at the given position
      * @throws IOException If we can't read the stream
      * @throws LdapSchemaException If we have no char to read
      */
     private static boolean startsWith( Reader reader, PosSchema pos, char c, boolean quoted ) throws IOException, LdapSchemaException
     {
         if ( ( pos.line == null ) || ( pos.line.length() - pos.start < 1 ) )
         {
             return false;
         }
         
         if ( quoted )
         {
             // Don't read a new line when we are within quotes
             return pos.line.charAt( pos.start ) == c;
         }
 
         while ( isEmpty( pos ) || ( isComment( pos ) ) )
         {
             getLine( reader, pos );
             
             if ( pos.line == null )
             {
                 return false;
             }
             
             skipWhites( reader, pos, false );
             
             if ( isComment( pos ) )
             {
                 continue;
             }
         }
         
         return pos.line.charAt( pos.start ) == c;
     }
     
     
     /**
      * @param pos The position in the Schema
      * @param c The char to find at the beginning of the line
      * @return <tt>true</tt> if the char is found at the beginning of the line
      */
     private static boolean startsWith( PosSchema pos, char c )
     {
         if ( ( pos.line == null ) || ( pos.line.length() - pos.start < 1 ) )
         {
             return false;
         }
         
         return pos.line.charAt( pos.start ) == c;
     }
 
     
     /**
      * @param pos The position in the Schema
      * @return <tt>true</tt> if the first char is alphabetic
      */
     private static boolean isAlpha( PosSchema pos )
     {
         return Character.isAlphabetic( pos.line.charAt( pos.start ) );
     }
     
     
     /**
      * @param pos The position in the Schema
      * @return <tt>true</tt> if the first char is a digit
      */
     private static boolean isDigit( PosSchema pos )
     {
         return Character.isDigit( pos.line.charAt( pos.start ) );
     }
 
     
     /**
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @throws IOException If the stream can't be read
      */
     private static void getLine( Reader reader, PosSchema pos ) throws IOException
     {
         pos.line = ( ( BufferedReader ) reader ).readLine();
         pos.start = 0;
         
         if ( pos.line != null )
         {
             pos.lineNumber++;
         }
     }
     
     
     /**
      * <pre>
      * numericoid   ::= number ( DOT number )+
      * number       ::= DIGIT | LDIGIT DIGIT+
      * DIGIT        ::= %x30 | LDIGIT       ; "0"-"9"
      * LDIGIT       ::= %x31-39             ; "1"-"9"
      * DOT          ::= %x2E                ; period (".")
      * </pre>
      * 
      * @param pos The position in the Schema
      * @return The numeric OID
      * @throws LdapSchemaException If the schema is wrong
      */
     private static String getNumericOid( PosSchema pos ) throws LdapSchemaException
     {
         int start = pos.start;
         boolean isDot = false;
         boolean isFirstZero = false;
         boolean isFirstDigit = true; 
         
         while ( !isEmpty( pos ) )
         {
             char c = pos.line.charAt( pos.start );
             
             if ( Character.isDigit( c ) )
             {
                 if ( isFirstZero )
                 {
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13784_BAD_OID_TWO_ZEROES, pos.lineNumber, pos.start ) );
                 }
                     
                 if ( ( pos.line.charAt( pos.start ) == '0' ) && isFirstDigit )
                 {
                     isFirstZero = true;
                 }
                 
                 isDot = false;
                 pos.start++;
                 isFirstDigit = false;
             }
             else if ( c == DOT )
             {
                 if ( isDot )
                 {
                     // We can't have two consecutive dots or a dot at the beginning
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13785_BAD_OID_CONSECUTIVE_DOTS, pos.lineNumber, pos.start ) );
                 }
                 
                 isFirstZero = false;
                 isFirstDigit = true;
                 pos.start++;
                 isDot = true;
             }
             else
             {
                 break;
             }
         }
         
         if ( isDot )
         {
             // We can't have two consecutive dots or a dot at the beginning
             throw new LdapSchemaException( I18n.err( I18n.ERR_13786_BAD_OID_DOT_AT_THE_END, pos.lineNumber, pos.start ) );
         }
 
         String oidStr = pos.line.substring( start, pos.start );
 
         if ( Oid.isOid( oidStr ) )
         {
             return oidStr;
         }
         else
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.line, pos.start ) );
         }
     }
     
     
     /**
      * <pre>
      * partialNumericoid   ::= number ( DOT number )*
      * number              ::= DIGIT | LDIGIT DIGIT+
      * DIGIT               ::= %x30 | LDIGIT       ; "0"-"9"
      * LDIGIT              ::= %x31-39             ; "1"-"9"
      * DOT                 ::= %x2E                ; period (".")
      * </pre>
      * 
      * @param pos The position in the Schema
      * @return The found OID
      * @throws LdapSchemaException If the schema is wrong
      */
     private static String getPartialNumericOid( PosSchema pos ) throws LdapSchemaException
     {
         int start = pos.start;
         boolean isDot = false;
         boolean isFirstZero = false;
         boolean isFirstDigit = true; 
         
         while ( !isEmpty( pos ) )
         {
             if ( isDigit( pos ) )
             {
                 if ( isFirstZero )
                 {
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13784_BAD_OID_TWO_ZEROES, pos.lineNumber, pos.start ) );
                 }
                     
                 if ( ( pos.line.charAt( pos.start ) == '0' ) && isFirstDigit )
                 {
                     isFirstZero = true;
                 }
                 
                 isDot = false;
                 pos.start++;
                 isFirstDigit = false;
             }
             else if ( startsWith( pos, DOT ) )
             {
                 if ( isDot )
                 {
                     // We can't have two consecutive dots or a dot at the beginning
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13785_BAD_OID_CONSECUTIVE_DOTS, pos.lineNumber, pos.start ) );
                 }
                 
                 isFirstZero = false;
                 isFirstDigit = true;
                 pos.start++;
                 isDot = true;
             }
             else
             {
                 break;
             }
         }
         
         if ( isDot )
         {
             // We can't have two consecutive dots or a dot at the beginning
             throw new LdapSchemaException( I18n.err( I18n.ERR_13786_BAD_OID_DOT_AT_THE_END, pos.lineNumber, pos.start ) );
         }
 
         return pos.line.substring( start, pos.start );
     }
 
     
 
     
     /**
      * In relaxed mode :
      * <pre>
      * oid          ::= descr | numericoid
      * descr        ::= descrQ (COLON numericoid)
      * descrQ       ::= keystringQ
      * keystringQ   ::= LkeycharQ keycharQ*
      * LkeycharQ    ::= ALPHA | HYPHEN | UNDERSCORE | SEMI_COLON | DOT | COLON | SHARP 
      * keycharQ     ::= ALPHA | DIGIT | HYPHEN | UNDERSCORE | SEMI_COLON | DOT | COLON | SHARP 
      * numericoid   ::= number ( DOT number )+
      * number       ::= DIGIT | LDIGIT DIGIT+
      * ALPHA        ::= %x41-5A | %x61-7A   ; "A"-"Z" / "a"-"z"
      * DIGIT        ::= %x30 | LDIGIT       ; "0"-"9"
      * LDIGIT       ::= %x31-39             ; "1"-"9"
      * HYPHEN       ::= %x2D                ; hyphen ("-")
      * UNDERSCORE   ::= %x5F                ; underscore ("_")
      * DOT          ::= %x2E                ; period (".")
      * COLON        ::= %x3A                ; colon (":")
      * SEMI_COLON   ::= %x3B                ; semi-colon(";")
      * SHARP        ::= %x23                ; octothorpe (or sharp sign) ("#")
      * </pre>
      * 
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return The found OID
      * @throws LdapSchemaException If the schema is wrong
      */
     private static String getOidAndMacroRelaxed( PosSchema pos, 
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws LdapSchemaException
     {
         if ( isEmpty( pos ) )
         {
             return "";
         }
 
         // This is a OID name
         int start = pos.start;
         char c = pos.line.charAt( pos.start );
         boolean isDigit = Character.isDigit( c );
         
         while ( isDigit || Character.isAlphabetic( c ) || ( c == HYPHEN ) || ( c == UNDERSCORE )
             || ( c == SEMI_COLON ) || ( c == DOT ) || ( c == SHARP ) )
         {
             pos.start++;
             
             if ( isEmpty( pos ) )
             {
                 break;
             }
             
             c = pos.line.charAt( pos.start );
             isDigit = Character.isDigit( c );
         }
         
         String oidName = pos.line.substring( start, pos.start  );
         
         if ( Strings.isEmpty( oidName ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
         
         // We may have a ':' followed by an OID
         if ( startsWith( pos, COLON ) )
         {
             pos.start++;
             String oid = getPartialNumericOid( pos );
             
             return objectIdentifierMacros.get( oidName ).getRawOidOrNameSuffix() + DOT + oid;
         }
         else
         {
             // Ok, we may just have an oidName
             OpenLdapObjectIdentifierMacro macro = objectIdentifierMacros.get( oidName );
             
             if ( macro == null )
             {
                 return oidName;
             }
             else
             {
                 return macro.getRawOidOrNameSuffix();
             }
         }
     }
 
     
     /**
      * In normal mode :
      * <pre>
      * oid          ::= descr | numericoid
      * descr        ::= keystring
      * keystring    ::= leadkeychar keychar*
      * leadkeychar  ::= ALPHA
      * keychar      ::= ALPHA | DIGIT | HYPHEN
      * numericoid   ::= number ( DOT number )+ |
      * number       ::= DIGIT | LDIGIT DIGIT+
      * ALPHA        ::= %x41-5A | %x61-7A   ; "A"-"Z" / "a"-"z"
      * DIGIT        ::= %x30 | LDIGIT       ; "0"-"9"
      * LDIGIT       ::= %x31-39             ; "1"-"9"
      * DOT          ::= %x2E                ; period (".")
      * HYPHEN       ::= %x2D                ; hyphen ("-")
      * </pre>
      * 
      * @param pos The position in the Schema
      * @return The found OID
      * @throws LdapSchemaException If the schema is wrong
      */
     private static String getOidStrict( PosSchema pos ) throws LdapSchemaException
     {
         if ( isEmpty( pos ) )
         {
             return "";
         }
 
         if ( isAlpha( pos ) )
         {
             // A descr
             return getDescrStrict( pos );
         }
         else if ( isDigit( pos ) )
         {
             // This is a numeric oid
             return getNumericOid( pos );
         }
         else
         {
             // This is an error
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
     }
 
     
     /**
      * In quirks mode :
      * <pre>
      * oid          ::= descr-relaxed | numericoid | SQUOTE descr-relaxed SQUOTE |
      *                  DQUOTE descr-relaxed DQUOTE | SQUOTE numericoid SQUOTE |
      *                  DQUOTE numericoid DQUOTE
      * descr-relaxed::= macro (COLON numericoid)
      * macro        ::= keystring
      * keystring    ::= Lkeychar  keychar*
      * Lkeychar     ::= ALPHA | HYPHEN | UNDERSCORE | SEMI_COLON | DOT | COLON | SHARP 
      * keychar      ::= ALPHA | DIGIT | HYPHEN | UNDERSCORE | SEMI_COLON | DOT | COLON | SHARP 
      * numericoid   ::= number ( DOT number )+
      * number       ::= DIGIT | LDIGIT DIGIT+
      * ALPHA        ::= %x41-5A | %x61-7A   ; "A"-"Z" / "a"-"z"
      * DIGIT        ::= %x30 | LDIGIT       ; "0"-"9"
      * LDIGIT       ::= %x31-39             ; "1"-"9"
      * HYPHEN       ::= %x2D                ; hyphen ("-")
      * UNDERSCORE   ::= %x5F                ; underscore ("_")
      * DOT          ::= %x2E                ; period (".")
      * COLON        ::= %x3A                ; colon (":")
      * SEMI_COLON   ::= %x3B                ; semi-colon(";")
      * SHARP        ::= %x23                ; octothorpe (or sharp sign) ("#")
      * </pre>
      * 
      * @param pos The position in the Schema
      * @param hadQuote If we have had a quote
      * @return the found OID
      * @throws LdapSchemaException If the schema is wrong
      */
     private static String getOidRelaxed( PosSchema pos, boolean hadQuote ) throws LdapSchemaException
     {
         if ( isEmpty( pos ) )
         {
             return "";
         }
         
         boolean hasQuote = false;
 
         char c = pos.line.charAt( pos.start );
         
         if ( c == SQUOTE )
         {
             if ( hadQuote )
             {
                 return "";
             }
             
             hasQuote = true;
             pos.start++;
 
             if ( isEmpty( pos ) )
             {
                 return "";
             }
             
             c = pos.line.charAt( pos.start );
         }
         
         String oid;
 
         if ( Character.isAlphabetic( c ) )
         {
             // This is a OID name
             oid = getDescrRelaxed( pos );
         }
         else if ( Character.isDigit( c ) )
         {
             // This is a numeric oid
             oid = getNumericOid( pos );
         }
         else
         {
             // This is an error
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, 
                 pos.lineNumber, pos.start ) );
         }
         
         if ( isEmpty( pos ) )
         {
             if ( hasQuote || hadQuote )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13792_SIMPLE_QUOTE_EXPECTED_AT_END, 
                     pos.lineNumber, pos.start ) );
             }
             else
             {
                 return oid;
             }
         }
         
         c = pos.line.charAt( pos.start );
         
         if ( ( c == SQUOTE ) && !hadQuote )
         {
            if ( hasQuote )
            {
                pos.start++;
            }
            else
            {
                throw new LdapSchemaException( I18n.err( I18n.ERR_13792_SIMPLE_QUOTE_EXPECTED_AT_END, 
                    pos.lineNumber, pos.start ) );
            }
         }
         
         return oid;
     }
     
     
     /**
      * In strict mode :
      * 
      * <pre>
      * descr        ::= keystring
      * keystring    ::= leadkeychar keychar*
      * leadkeychar  ::= ALPHA
      * keychar      ::= ALPHA | DIGIT | HYPHEN
      * numericoid   ::= number ( DOT number )+ |
      * number       ::= DIGIT | LDIGIT DIGIT+
      * ALPHA        ::= %x41-5A | %x61-7A   ; "A"-"Z" / "a"-"z"
      * DIGIT        ::= %x30 | LDIGIT       ; "0"-"9"
      * LDIGIT       ::= %x31-39             ; "1"-"9"
      * DOT          ::= %x2E                ; period (".")
      * HYPHEN       ::= %x2D                ; hyphen ("-")
      * </pre>
      * 
      * @param pos The position in the Schema
      * @return The descr
      * @throws LdapSchemaException If the schema is wrong
      */
     private static String getDescrStrict( PosSchema pos ) throws LdapSchemaException
     {
         int start = pos.start;
         boolean isFirst = true;
         
         while ( !isEmpty( pos ) )
         {
             if ( isFirst )
             {
                 isFirst = false;
                 
                 if ( isAlpha( pos ) ) 
                 {
                     // leadkeychar
                     pos.start++;
                 }
                 else
                 {
                     // Error, we are expecting a leadKeychar
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13788_LEAD_KEY_CHAR_EXPECTED, 
                         pos.lineNumber, pos.start ) );
                 }
             }
             else
             {
                 char c = pos.line.charAt( pos.start );
                 
                 if ( Character.isAlphabetic( c ) || Character.isDigit( c ) || ( c == HYPHEN ) )
                 {
                     pos.start++;
                 }
                 else
                 {
                     // We are done 
                     return pos.line.substring( start, pos.start );
                 }
             }
         }
 
         return pos.line.substring( start, pos.start );
     }
     
     
     
     /**
      * In quirksMode :
      * 
      * <pre>
      * descr        ::= descrQ (COLON numericoid)
      * descrQ       ::= keystringQ
      * keystringQ   ::= LkeycharQ keycharQ*
      * LkeycharQ    ::= ALPHA | HYPHEN | UNDERSCORE | SEMI_COLON | DOT | COLON | SHARP 
      * keycharQ     ::= ALPHA | DIGIT | HYPHEN | UNDERSCORE | SEMI_COLON | DOT | COLON | SHARP 
      * numericoid   ::= number ( DOT number )+
      * number       ::= DIGIT | LDIGIT DIGIT+
      * ALPHA        ::= %x41-5A | %x61-7A   ; "A"-"Z" / "a"-"z"
      * DIGIT        ::= %x30 | LDIGIT       ; "0"-"9"
      * LDIGIT       ::= %x31-39             ; "1"-"9"
      * HYPHEN       ::= %x2D                ; hyphen ("-")
      * UNDERSCORE   ::= %x5F                ; underscore ("_")
      * DOT          ::= %x2E                ; period (".")
      * COLON        ::= %x3A                ; colon (":")
      * SEMI_COLON   ::= %x3B                ; semi-colon(";")
      * SHARP        ::= %x23                ; octothorpe (or sharp sign) ("#")
      * </pre>
      * 
      * @param pos The position in the Schema
      * @return The descr
      * @throws LdapSchemaException If the schema is wrong
      */
     private static String getDescrRelaxed( PosSchema pos ) throws LdapSchemaException
     {
         int start = pos.start;
         boolean isFirst = true;
         
         while ( !isEmpty( pos ) )
         {
             if ( isFirst )
             {
                 isFirst = false;
                 
                 char c = pos.line.charAt( pos.start );
                 
                 if ( Character.isAlphabetic( c ) || ( c == HYPHEN ) || ( c == UNDERSCORE )
                     || ( c == SEMI_COLON ) || ( c == DOT ) || ( c == COLON ) || ( c == SHARP ) ) 
                 {
                     // leadkeycharQ
                     pos.start++;
                 }
                 else
                 {
                     // Error, we are expecting a leadKeychar
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13788_LEAD_KEY_CHAR_EXPECTED, 
                         pos.lineNumber, pos.start ) );
                 }
             }
             else
             {
                 char c = pos.line.charAt( pos.start );
                 
                 if ( Character.isAlphabetic( c ) || Character.isDigit( c ) || ( c == HYPHEN )
                     || ( c == UNDERSCORE ) || ( c == SEMI_COLON ) || ( c == DOT ) || ( c == COLON ) || ( c == SHARP ) ) 
                 {
                     pos.start++;
                 }
                 else
                 {
                     // We are done 
                     return pos.line.substring( start, pos.start );
                 }
             }
         }
         
         return pos.line.substring( start, pos.start );
     }
     
     
     /**
      * 
      * @param pos The position in the Schema
      * @return The found macro, if any
      * @throws LdapSchemaException If the schema is wrong
      */
     private String getMacro( PosSchema pos ) throws LdapSchemaException
     {
         if ( isQuirksModeEnabled )
         {
             int start = pos.start;
             boolean isFirst = true;
             
             while ( !isEmpty( pos ) )
             {
                 if ( isFirst )
                 {
                     isFirst = false;
                     
                     char c = pos.line.charAt( pos.start );
                     
                     if ( Character.isAlphabetic( c ) || ( c == HYPHEN ) || ( c == UNDERSCORE ) 
                         || ( c == SEMI_COLON ) || ( c == DOT ) || ( c == SHARP ) ) 
                     {
                         // leadkeycharQ
                         pos.start++;
                     }
                     else
                     {
                         // Error, we are expecting a leadKeychar
                         throw new LdapSchemaException( I18n.err( I18n.ERR_13788_LEAD_KEY_CHAR_EXPECTED, 
                             pos.lineNumber, pos.start ) );
                     }
                 }
                 else
                 {
                     char c = pos.line.charAt( pos.start );
                     
                     if ( Character.isAlphabetic( c ) || Character.isDigit( c ) || ( c == HYPHEN ) 
                         || ( c == UNDERSCORE ) || ( c == SEMI_COLON ) || ( c == DOT ) || ( c == SHARP ) ) 
                     {
                         pos.start++;
                     }
                     else
                     {
                         // We are done 
                         return pos.line.substring( start, pos.start );
                     }
                 }
             }
             
             return pos.line.substring( start, pos.start );
         }
         else
         {
             int start = pos.start;
             boolean isFirst = true;
             
             while ( !isEmpty( pos ) )
             {
                 if ( isFirst )
                 {
                     isFirst = false;
                     
                     if ( isAlpha( pos ) ) 
                     {
                         // leadkeychar
                         pos.start++;
                     }
                     else
                     {
                         // Error, we are expecting a leadKeychar
                         throw new LdapSchemaException( I18n.err( I18n.ERR_13788_LEAD_KEY_CHAR_EXPECTED, 
                             pos.lineNumber, pos.start ) );
                     }
                 }
                 else
                 {
                     char c = pos.line.charAt( pos.start );
                     
                     if ( Character.isAlphabetic( c ) || Character.isDigit( c ) || ( c == HYPHEN ) )
                     {
                         pos.start++;
                     }
                     else
                     {
                         // We are done 
                         return pos.line.substring( start, pos.start );
                     }
                 }
             }
 
             return pos.line.substring( start, pos.start );
         }
     }
     
     
     /**
      * <pre>
      * qdescr ::== SQUOTE descr SQUOTE
      * descr ::= keystring
      * keystring ::= leadkeychar *keychar
      * leadkeychar ::= ALPHA
      * keychar ::= ALPHA | DIGIT | HYPHEN
      * </pre>
      * 
      * In quirksMode :
      * 
      * <pre>
      * qdescr ::== SQUOTE descr SQUOTE | descr | SQUOTE numericoid SQUOTE
      * descr ::= keystring
      * keystring ::= keychar+
      * keychar ::= ALPHA | DIGIT | HYPHEN | UNDERSCORE | SEMI_COLON | DOT | COLON | SHARP 
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @return The QDescr
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static String getQDescrStrict( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
         // The first quote
         if ( !startsWith( reader, pos, SQUOTE ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13789_SIMPLE_QUOTE_EXPECTED_AT_START, 
                 pos.lineNumber, pos.start ) );
         }
         
         pos.start++;
         int start = pos.start;
         boolean isFirst = true;
         
         while ( !startsWith( pos, SQUOTE ) )
         {
             if ( isFirst )
             {
                 isFirst = false;
                 
                 if ( !isEmpty( pos ) && isAlpha( pos ) ) 
                 {
                     // leadkeychar
                     pos.start++;
                 }
                 else
                 {
                     // Error, we are expecting a leadKeychar
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13788_LEAD_KEY_CHAR_EXPECTED, 
                         pos.lineNumber, pos.start ) );
                 }
             }
             else
             {
                 if ( isEmpty( pos ) )
                 {
                     // This is an error
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13792_SIMPLE_QUOTE_EXPECTED_AT_END, 
                         pos.lineNumber, pos.start ) );
                 }
                 
                 char c = pos.line.charAt( pos.start );
                 
                 if ( Character.isAlphabetic( c ) || Character.isDigit( c ) || ( c == HYPHEN ) )
                 {
                     pos.start++;
                 }
                 else
                 {
                     // This is an error
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13791_KEYCHAR_EXPECTED, c, 
                         pos.lineNumber, pos.start ) );
                 }
             }
         }
         
         if ( startsWith( pos, SQUOTE ) )
         {
             // We are done, move one char forward to eliminate the simple quote
             pos.start++;
             
             return pos.line.substring( start, pos.start - 1 );
         }
         else
         {
             // No closing simple quote, this is an error
             throw new LdapSchemaException( I18n.err( I18n.ERR_13792_SIMPLE_QUOTE_EXPECTED_AT_END, 
                 pos.lineNumber, pos.start ) );
         }
     }
     
     
     /**
      * <pre>
      * qdescr ::== SQUOTE descr SQUOTE
      * descr ::= keystring
      * keystring ::= leadkeychar *keychar
      * leadkeychar ::= ALPHA
      * keychar ::= ALPHA | DIGIT | HYPHEN
      * </pre>
      * 
      * In quirksMode :
      * 
      * <pre>
      * qdescr ::== SQUOTE descr SQUOTE | descr | SQUOTE numericoid SQUOTE
      * descr ::= keystring
      * keystring ::= keychar+
      * keychar ::= ALPHA | DIGIT | HYPHEN | UNDERSCORE | SEMI_COLON | DOT | COLON | SHARP 
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @return the QDescr
      * @throws IOException If the stream can't be read
      * @throws LdapSchemaException If the schema is wrong
      */
     private static String getQDescrRelaxed( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
         if ( startsWith( reader, pos, SQUOTE ) )
         {
             pos.start++;
             int start = pos.start;
             
             while ( !startsWith( pos, SQUOTE ) )
             {
                 if ( isEmpty( pos ) )
                 {
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13789_SIMPLE_QUOTE_EXPECTED_AT_START, 
                         pos.lineNumber, pos.start ) );
                 }
                 
                 char c = pos.line.charAt( pos.start );
                 
                 if ( Character.isDigit( c ) || Character.isAlphabetic( c ) || ( c == HYPHEN ) || ( c == UNDERSCORE )
                     || ( c == SEMI_COLON ) || ( c == DOT ) || ( c == COLON ) || ( c == SHARP ) )
                 {
                     pos.start++;
                 }
                 else if ( c != SQUOTE )
                 {
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13790_NOT_A_KEYSTRING, pos.lineNumber, pos.start ) );
                 }
             }
             
             pos.start++;
             
             return pos.line.substring( start, pos.start - 1 );
         }
         else
         {
             int start = pos.start;
             
             while ( !isEmpty( pos ) )
             {
                 char c = pos.line.charAt( pos.start );
 
                 if ( Character.isDigit( c ) || Character.isAlphabetic( c ) || ( c == HYPHEN ) || ( c == UNDERSCORE )
                     || ( c == SEMI_COLON ) || ( c == DOT ) || ( c == COLON ) || ( c == SHARP ) )
                 {
                     pos.start++;
                 }
                 else
                 {
                     break;
                 }
             }
 
             return pos.line.substring( start, pos.start );
         }
     }
     
     
     /**
      * No relaxed version.
      * <pre>
      * qdstring ::== SQUOTE dstring SQUOTE
      * dstring  ::= ( QS | QQ | QUTF8 )+            ; escaped UTF-8 string
      * QS       ::= ESC %x35 ( %x43 | %x63 )        ; "\5C" | "\5c", escape char
      * QQ       ::= ESC %x32 %x37                   ; "\27", simple quote char
      * QUTF8    ::= QUTF1 | UTFMB
      * QUTF1    ::= %x00-26 | %x28-5B | %x5D-7F     ; All ascii but ' and \
      * UTFMB    ::= UTF2 | UTF3 | UTF4
      * UTF0     ::= %x80-BF
      * UTF2     ::= %xC2-DF UTF0
      * UTF3     ::= %xE0 %xA0-BF UTF0 | %xE1-EC UTF0 UTF0 | %xED %x80-9F UTF0 | %xEE-EF UTF0 UTF0
      * UTF4     ::= %xF0 %x90-BF UTF0 UTF0 | %xF1-F3 UTF0 UTF0 UTF0 | %xF4 %x80-8F UTF0 UTF0
      * ESC      ::= %x5C                            ; backslash ("\")
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @return The QDString
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static String getQDString( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
         // The first quote
         if ( !startsWith( reader, pos, SQUOTE ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13789_SIMPLE_QUOTE_EXPECTED_AT_START, 
                 pos.lineNumber, pos.start ) );
         }
         
         pos.start++;
         int start = pos.start;
         int nbEscapes = 0;
         
         while ( !isEmpty( pos ) && !startsWith( pos, SQUOTE ) )
         {
             // At the moment, just swallow anything
             if ( startsWith( pos, ESCAPE ) )
             {
                 nbEscapes++;
             }
             
             pos.start++;
             
         }
         
         if ( startsWith( pos, SQUOTE ) )
         {
             // We are done, move one char forward to eliminate the simple quote
             pos.start++;
             
             // Now, un-escape the escaped chars
             char[] unescaped = new char[pos.start - 1 - start - nbEscapes * 2];
             int newPos = 0;
             
             for ( int i = start; i < pos.start - 1; i++ )
             {
                 char c = pos.line.charAt( i );
                 
                 if ( c == ESCAPE )
                 {
                     if ( i + 2 > pos.start )
                     {
                         // Error : not enough hex value
                         throw new LdapSchemaException( I18n.err( I18n.ERR_13792_SIMPLE_QUOTE_EXPECTED_AT_END, 
                             pos.lineNumber, pos.start ) );
                     }
                     
                     int u = Character.digit( pos.line.charAt( i + 1 ), 16 );
                     int l = Character.digit( pos.line.charAt( i + 2 ), 16 );
 
                     unescaped[newPos] = ( char ) ( ( u << 4 ) + l );
                     i += 2;
                 }
                 else
                 {
                     unescaped[newPos] = c;
                 }
                 
                 newPos++;
             }
             
             return new String( unescaped );
         }
         else
         {
             // No closing simple quote, this is an error
             throw new LdapSchemaException( I18n.err( I18n.ERR_13792_SIMPLE_QUOTE_EXPECTED_AT_END, 
                 pos.lineNumber, pos.start ) );
         }
     }
 
 
     /**
      * <pre>
      * qdescrs ::= qdescr | LPAREN WSP qdescrlist WSP RPAREN
      * qdescrlist ::= [ qdescr *( SP qdescr ) ]
      * qdescr ::== SQUOTE descr SQUOTE
      * descr ::= keystring
      * keystring ::= leadkeychar *keychar
      * leadkeychar ::= ALPHA
      * keychar ::= ALPHA / DIGIT / HYPHEN
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param relaxed If the schema is to be processed in relaxed mode
      * @return The list of QDescr
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static List<String> getQDescrs( Reader reader, PosSchema pos, boolean relaxed ) 
             throws LdapSchemaException, IOException
     {
         List<String> qdescrs = new ArrayList<>();
         
         // It may start with a '('
         if ( startsWith( reader, pos, LPAREN ) )
         {
             pos.start++;
             
             // We have more than a name
             skipWhites( reader, pos, false );
             
             while ( !startsWith( reader, pos, RPAREN ) )
             {
                 String qdescr;
                 
                 if ( relaxed )
                 {
                     qdescr = getQDescrRelaxed( reader, pos );
                 }
                 else
                 {
                     qdescr = getQDescrStrict( reader, pos );
                 }
                 
                 qdescrs.add( qdescr );
                 
                 if ( startsWith( reader, pos, RPAREN ) )
                 {
                     break;
                 }
                 
                 skipWhites( reader, pos, true );
             }
             
             if ( !startsWith( reader, pos, RPAREN ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13793_NO_CLOSING_PAREN, 
                     pos.lineNumber, pos.start ) );
             }
             
             pos.start++;
         }
         else
         {
             // Only one name, read it
             String qDescr;
             
             if ( relaxed )
             {
                 qDescr = getQDescrRelaxed( reader, pos );
             }
             else
             {
                 qDescr = getQDescrStrict( reader, pos );
             }
             
             if ( Strings.isEmpty( qDescr ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13732_NAME_CANNOT_BE_NULL, pos.lineNumber, pos.start ) );
             }
             
             qdescrs.add( qDescr );
         }
         
         return qdescrs;
     }
 
 
     /**
      * <pre>
      * qdstrings    ::= qdstring | ( LPAREN WSP qdstringlist WSP RPAREN )
      * qdstringlist ::= qdstring *( SP qdstring )*
      * qdstring     ::= SQUOTE dstring SQUOTE
      * dstring      ::= 1*( QS / QQ / QUTF8 )   ; escaped UTF-8 string
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @return The list of QDString
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static List<String> getQDStrings( Reader reader, PosSchema pos ) 
         throws LdapSchemaException, IOException
     {
         List<String> qdStrings = new ArrayList<>();
         
         // It may start with a '('
         if ( startsWith( reader, pos, LPAREN ) )
         {
             pos.start++;
             
             // We have more than a name
             skipWhites( reader, pos, false );
             
             while ( !startsWith( reader, pos, RPAREN ) )
             {
                 qdStrings.add( getQDString( reader, pos ) );
                 
                 if ( startsWith( reader, pos, RPAREN ) )
                 {
                     break;
                 }
                 
                 skipWhites( reader, pos, true );
             }
             
             if ( !startsWith( reader, pos, RPAREN ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13793_NO_CLOSING_PAREN, 
                     pos.lineNumber, pos.start ) );
             }
             
             pos.start++;
         }
         else
         {
             // Only one name, read it
             qdStrings.add( getQDString( reader, pos ) );
         }
         
         return qdStrings;
     }
 
     
     /**
      * <pre>
      * oids     ::= oid | ( LPAREN WSP oidlist WSP RPAREN )
      * oidlist  ::= oid *( WSP DOLLAR WSP oid )
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @return The list of OIDs
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static List<String> getOidsStrict( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
         List<String> oids = new ArrayList<>();
         
         // It may start with a '('
         if ( startsWith( reader, pos, LPAREN ) )
         {
             pos.start++;
             
             // We have more than a name
             skipWhites( reader, pos, false );
             boolean moreExpected = false;
             
             while ( !startsWith( reader, pos, RPAREN ) )
             {
                 moreExpected = false;
                 
                 oids.add( getOidStrict( pos ) );
                 
                 if ( startsWith( reader, pos, RPAREN ) )
                 {
                     break;
                 }
                 
                 skipWhites( reader, pos, false );
                 
                 if ( startsWith( reader, pos, DOLLAR ) )
                 {
                     pos.start++;
                     moreExpected = true;
                 }
 
                 skipWhites( reader, pos, false );
             }
             
             if ( !startsWith( reader, pos, RPAREN ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13793_NO_CLOSING_PAREN, 
                     pos.lineNumber, pos.start ) );
             }
             
             if ( moreExpected )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13794_MORE_OIDS_EXPECTED, 
                     pos.lineNumber, pos.start ) );
             }
             
             pos.start++;
         }
         else
         {
             // Only one name, read it
             oids.add( getOidStrict( pos ) );
         }
         
         return oids;
     }
 
     
     /**
      * <pre>
      * oids     ::= oid | ( LPAREN WSP oidlist WSP RPAREN )
      * oidlist  ::= oid *( WSP DOLLAR WSP oid )
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @return The list of OIDs
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static List<String> getOidsRelaxed( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
         List<String> oids = new ArrayList<>();
         
         // It may start with a '('
         if ( startsWith( reader, pos, LPAREN ) )
         {
             pos.start++;
             
             // We have more than a name
             skipWhites( reader, pos, false );
             boolean moreExpected = false;
             
             while ( !startsWith( reader, pos, RPAREN ) )
             {
                 moreExpected = false;
                 
                 oids.add( getOidRelaxed( pos, UN_QUOTED ) );
                 
                 if ( startsWith( reader, pos, RPAREN ) )
                 {
                     break;
                 }
                 
                 skipWhites( reader, pos, false );
                 
                 if ( startsWith( reader, pos, DOLLAR ) )
                 {
                     pos.start++;
                     moreExpected = true;
                 }
 
                 skipWhites( reader, pos, false );
             }
             
             if ( !startsWith( reader, pos, RPAREN ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13793_NO_CLOSING_PAREN, 
                     pos.lineNumber, pos.start ) );
             }
             
             if ( moreExpected )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13794_MORE_OIDS_EXPECTED, 
                     pos.lineNumber, pos.start ) );
             }
             
             pos.start++;
         }
         else
         {
             // Only one name, read it
             oids.add( getOidRelaxed( pos, UN_QUOTED ) );
         }
         
         return oids;
     }
 
     
     /**
      * <pre>
      * noidlen = oidStrict [ LCURLY len RCURLY ]
      * </pre>
      *  
      * @param attributeType The AttributeType
      * @param pos The position in the Schema
      * @throws LdapSchemaException If the schema is wrong
      */
     private static void getNoidLenStrict( AttributeType attributeType, PosSchema pos ) throws LdapSchemaException
     {
         // Get the oid
         String oid = getOidStrict( pos );
         
         if ( oid.length() == 0 )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13828_MISSING_SYNTAX_OID, pos.line, pos.start ) );
         }
         
         attributeType.setSyntaxOid( oid );
 
         // Then the len, if any
         if ( startsWith( pos, LBRACE ) )
         {
             pos.start++;
             int start = pos.start;
             
             while ( !isEmpty( pos ) && isDigit( pos ) )
             {
                 pos.start++;
             }
             
             if ( startsWith( pos, RBRACE ) )
             {
                 String lenStr = pos.line.substring( start, pos.start );
                 
                 if ( lenStr.length() == 0 )
                 {
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13827_EMPTY_SYNTAX_LEN, pos.line, pos.start ) );
                 }
                 
                 pos.start++;
                 
                 if ( Strings.isEmpty( lenStr ) )
                 {
                     attributeType.setSyntaxLength( -1L );
                 }
                 else
                 {
                     attributeType.setSyntaxLength( Long.parseLong( lenStr ) );
                 }
             }
             else
             {
                 // The opening curly hasn't been closed
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13795_OPENED_BRACKET_NOT_CLOSED, 
                     pos.lineNumber, pos.start ) );
             }
         }
     }
 
     
     /**
      * <pre>
      * noidlen = oidRelaxed [ LCURLY len RCURLY ]
      * </pre>
      * 
      * @param attributeType The AttributeType
      * @param pos The position in the Schema
      * @throws LdapSchemaException If the schema is wrong
      */
     private static void getNoidLenRelaxed( AttributeType attributeType, PosSchema pos ) throws LdapSchemaException
     {
         // Check for quotes
         boolean hasQuote = false;
 
         char c = pos.line.charAt( pos.start );
         
         if ( c == SQUOTE )
         {
             hasQuote = true;
             pos.start++;
 
             if ( isEmpty( pos ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13792_SIMPLE_QUOTE_EXPECTED_AT_END, 
                     pos.lineNumber, pos.start ) );
             }
         }
 
         // Get the oid
         String oid = getOidRelaxed( pos, hasQuote );
         
         if ( oid.length() == 0 )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13828_MISSING_SYNTAX_OID, pos.line, pos.start ) );
         }
         
         attributeType.setSyntaxOid( oid );
 
         // Then the len, if any
         if ( startsWith( pos, LBRACE ) )
         {
             pos.start++;
             int start = pos.start;
             
             while ( !isEmpty( pos ) && isDigit( pos ) )
             {
                 pos.start++;
             }
             
             if ( startsWith( pos, RBRACE ) )
             {
                 String lenStr = pos.line.substring( start, pos.start );
                 
                 pos.start++;
                 
                 if ( Strings.isEmpty( lenStr ) )
                 {
                     attributeType.setSyntaxLength( -1L );
                 }
                 else
                 {
                     attributeType.setSyntaxLength( Long.parseLong( lenStr ) );
                 }
             }
             else
             {
                 // The opening curly hasn't been closed
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13795_OPENED_BRACKET_NOT_CLOSED, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         if ( hasQuote )
         {
             if ( isEmpty( pos ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13792_SIMPLE_QUOTE_EXPECTED_AT_END, 
                     pos.lineNumber, pos.start ) );
             }
             
             c = pos.line.charAt( pos.start );
             
             if ( c == SQUOTE )
             {
                pos.start++;
            }
            else
            {
                throw new LdapSchemaException( I18n.err( I18n.ERR_13792_SIMPLE_QUOTE_EXPECTED_AT_END, 
                    pos.lineNumber, pos.start ) );
            }
         }
     }
     
 
     
     /**
      * <pre>
      * ruleid ::= number
      * number ::= DIGIT | LDIGIT DIGIT+
      * DIGIT  ::= [0-9]
      * LDIGIT ::= [1-9]
      * </pre>
      * 
      * @param pos The position in the Schema
      * @return The RuleID
      * @throws LdapSchemaException If the schema is wrong
      */
     private static int getRuleId( PosSchema pos ) throws LdapSchemaException
     {
         int start = pos.start;
 
         while ( !isEmpty( pos ) && isDigit( pos ) )
         {
             pos.start++;
         }
         
         if ( start == pos.start )
         {
             // No ruleID
             throw new LdapSchemaException( I18n.err( I18n.ERR_13811_INVALID_RULE_ID, 
                 pos.lineNumber, pos.start ) );
         }
 
         String lenStr = pos.line.substring( start, pos.start );
         
         return Integer.parseInt( lenStr );
     }
 
     
     /**
      * <pre>
      * ruleids      ::= ruleid | ( LPAREN WSP ruleidlist WSP RPAREN )
      * ruleidlist   ::= ruleid ( SP ruleid )*
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @return The list of RuleIDs
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static List<Integer> getRuleIds( Reader reader, PosSchema pos ) throws LdapSchemaException, IOException
     {
         List<Integer> ruleIds = new ArrayList<>();
         
         // It may start with a '('
         if ( startsWith( reader, pos, LPAREN ) )
         {
             pos.start++;
             
             // We may have more than a ruleid
             skipWhites( reader, pos, false );
             boolean moreExpected = false;
             
             while ( !startsWith( reader, pos, RPAREN ) )
             {
                 moreExpected = false;
                 
                 ruleIds.add( getRuleId( pos ) );
                 
                 if ( startsWith( reader, pos, RPAREN ) )
                 {
                     break;
                 }
                 
                 skipWhites( reader, pos, false );
                 
                 if ( startsWith( reader, pos, DOLLAR ) )
                 {
                     pos.start++;
                     moreExpected = true;
                 }
 
                 skipWhites( reader, pos, false );
             }
             
             if ( !startsWith( reader, pos, RPAREN ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13793_NO_CLOSING_PAREN, 
                     pos.lineNumber, pos.start ) );
             }
             
             if ( moreExpected )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13813_MORE_RULE_IDS_EXPECTED, 
                     pos.lineNumber, pos.start ) );
             }
             
             pos.start++;
         }
         else
         {
             // Only one ruleId, read it
             ruleIds.add( getRuleId( pos ) );
         }
         
         return ruleIds;
     }
     
     
     /**
      * 
      * @param pos The position in the Schema
      * @return The USAGE
      * @throws LdapSchemaException If the schema is wrong
      */
     private static UsageEnum getUsageStrict( PosSchema pos ) throws LdapSchemaException
     {
         if ( isEmpty( pos ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13796_USAGE_EXPECTED, 
                 pos.lineNumber, pos.start ) );
         }
         
         if ( startsWith( pos, USER_APPLICATIONS_STR ) )
         { 
             pos.start += USER_APPLICATIONS_STR.length();
             
             return UsageEnum.USER_APPLICATIONS;
         }
         else if ( startsWith( pos, DIRECTORY_OPERATION_STR ) )
         {
             pos.start += DIRECTORY_OPERATION_STR.length();
             
             return UsageEnum.DIRECTORY_OPERATION;
         }
         else if ( startsWith( pos, DISTRIBUTED_OPERATION_STR ) )
         { 
             pos.start += DISTRIBUTED_OPERATION_STR.length();
             
             return UsageEnum.DISTRIBUTED_OPERATION;
         }
         else if ( startsWith( pos, DSA_OPERATION_STR ) )
         { 
             pos.start += DSA_OPERATION_STR.length();
 
             return UsageEnum.DSA_OPERATION;
         }
         else
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13797_USAGE_UNKNOWN, 
                 pos.lineNumber, pos.start ) );
         }
     }
     
     
     /**
      * 
      * @param pos The position in the Schema
      * @return The USAGE
      * @throws LdapSchemaException If the schema is wrong
      */
     private static UsageEnum getUsageRelaxed( PosSchema pos ) throws LdapSchemaException
     {
         if ( isEmpty( pos ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13796_USAGE_EXPECTED, 
                 pos.lineNumber, pos.start ) );
         }
         
         boolean isSQuoted = false;
         boolean isDQuoted = false;
         
         if ( pos.line.charAt( pos.start ) == SQUOTE )
         {
             isSQuoted = true;
             pos.start++;
 
             if ( isEmpty( pos ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13796_USAGE_EXPECTED, 
                     pos.lineNumber, pos.start ) );
             }
         }
         else if ( pos.line.charAt( pos.start ) == DQUOTE )
         {
             isDQuoted = true;
             pos.start++;
 
             if ( isEmpty( pos ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13796_USAGE_EXPECTED, 
                     pos.lineNumber, pos.start ) );
             }
         }
 
         UsageEnum usage = UsageEnum.USER_APPLICATIONS;
 
         if ( startsWith( pos, USER_APPLICATIONS_STR ) )
         { 
             pos.start += USER_APPLICATIONS_STR.length();
             
             usage = UsageEnum.USER_APPLICATIONS;
         }
         else if ( startsWith( pos, DIRECTORY_OPERATION_STR ) )
         {
             pos.start += DIRECTORY_OPERATION_STR.length();
             
             usage = UsageEnum.DIRECTORY_OPERATION;
         } 
         else if ( startsWith( pos, DISTRIBUTED_OPERATION_STR ) )
         { 
             pos.start += DISTRIBUTED_OPERATION_STR.length();
             
             usage = UsageEnum.DISTRIBUTED_OPERATION;
         } 
         else if ( startsWith( pos, DSA_OPERATION_STR ) )
         { 
             pos.start += DSA_OPERATION_STR.length();
 
             usage = UsageEnum.DSA_OPERATION;
         } 
         else
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13797_USAGE_UNKNOWN, 
                 pos.lineNumber, pos.start ) );
         }
         
         if ( isSQuoted )
         {
             if ( isEmpty( pos ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13796_USAGE_EXPECTED, 
                     pos.lineNumber, pos.start ) );
             }
             
             if ( pos.line.charAt( pos.start ) != SQUOTE )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13792_SIMPLE_QUOTE_EXPECTED_AT_END, 
                     pos.lineNumber, pos.start ) );
             }
             
             pos.start++;
         }
         else if ( isDQuoted )
         {
             if ( isEmpty( pos ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13796_USAGE_EXPECTED, 
                     pos.lineNumber, pos.start ) );
             }
             
             if ( pos.line.charAt( pos.start ) != DQUOTE )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13792_SIMPLE_QUOTE_EXPECTED_AT_END, 
                     pos.lineNumber, pos.start ) );
             }
             
             pos.start++;
         }
         
         return usage;
     }
 
     
     /**
      * <pre>
      * extension    ::= xstring SP qdstrings
      * xstring      ::= "X" HYPHEN ( ALPHA | HYPHEN | USCORE )+
      * qdstrings    ::= qdstring | ( LPAREN WSP qdstringlist WSP RPAREN )
      * qdstringlist ::= qdstring *( SP qdstring )*
      * qdstring     ::= SQUOTE dstring SQUOTE
      * dstring      ::= 1*( QS / QQ / QUTF8 )   ; escaped UTF-8 string
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param schemaObject The SchemaObject
      * @throws IOException If the stream can't be read
      * @throws LdapSchemaException If the schema is wrong
      */
     private static void processExtension( Reader reader, PosSchema pos, SchemaObject schemaObject ) 
         throws LdapSchemaException, IOException
     {
         // The xstring first
         String extensionKey = getXString( pos );
         
         skipWhites( reader, pos, true );
         
         List<String> extensionValues = getQDStrings( reader, pos );
         
         if ( schemaObject.hasExtension( extensionKey ) )
         {
             throw new LdapSchemaException( 
                 I18n.err( I18n.ERR_13780_SCHEMA_OBJECT_DESCRIPTION_HAS_ELEMENT_TWICE, extensionKey, 
                 pos.lineNumber, pos.start ) );
         }
 
         schemaObject.addExtension( extensionKey, extensionValues );
     }
     
     
     /**
      * <pre>
      * xstring      ::= "X" HYPHEN ( ALPHA | HYPHEN | USCORE )+
      * </pre>
      * 
      * @param pos The position in the Schema
      * @return the X-String
      * @throws LdapSchemaException If the schema is wrong
      */
     private static String getXString( PosSchema pos ) throws LdapSchemaException
     {
         int start = pos.start;
         
         if ( startsWith( pos, EXTENSION_PREFIX ) )
         {
             pos.start += 2;
             
             // Now parse the remaining string
             while ( !isEmpty( pos ) && ( isAlpha( pos ) || startsWith( pos, HYPHEN ) || startsWith( pos, UNDERSCORE ) ) )
             {
                 pos.start++;
             }
             
             return pos.line.substring( start, pos.start );
         }
         else
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13802_EXTENSION_SHOULD_START_WITH_X, 
                 pos.lineNumber, pos.start ) );
         }
     }
     
     
     /**
      * A FQCN
      * <pre>
      * FQCN ::= FQCN_IDENTIFIER ( '.' FQCN_IDENTIFIER )*
      * FQCN_IDENTIFIER ::= ( JavaLetter ( JavaLetterOrDigit )*
      * </pre>
      * 
      * @param pos The position in the Schema
      * @return The FQCN
      * @throws LdapSchemaException If the schema is wrong
      */
     private static String getFqcn( PosSchema pos ) throws LdapSchemaException
     {
         if ( ( pos.line == null ) || ( pos.line.length() - pos.start < 1 ) )
         {
             return "";
         }
 
         int start = pos.start;
         boolean isFirst = true;
         boolean dotSeen = false;
         
         while ( true )
         {
             char c = pos.line.charAt( pos.start );
             
             if ( isFirst )
             {
                 if ( !Character.isJavaIdentifierStart( c ) )
                 {
                     throw new LdapSchemaException( I18n.err( I18n.ERR_13822_INVALID_FQCN_BAD_IDENTIFIER_START, 
                         pos.lineNumber, pos.start ) );
                 }
                 
                 isFirst = false;
                 dotSeen = false;
                 pos.start++;
             }
             else
             {
                 if ( c == DOT ) 
                 {
                     if ( dotSeen )
                     {
                         throw new LdapSchemaException( I18n.err( I18n.ERR_13823_INVALID_FQCN_DOUBLE_DOT, 
                             pos.lineNumber, pos.start ) );
                     }
                     else
                     {
                         isFirst = true;
                         dotSeen = true;
                         pos.start++;
                     }
                 }
                 else
                 {
                     if ( Character.isJavaIdentifierPart( c ) )
                     {
                         pos.start++;
                         dotSeen = false;
                     }
                     else
                     {
                         return pos.line.substring( start, pos.start );
                     }
                 }
             }
             
             if ( pos.line.length() - pos.start < 1 )
             {
                 return pos.line.substring( start, pos.start );
             }
         }
     }
 
     
     /**
      * A base64 string
      * <pre>
      * byteCode ::= ( [a-z] | [A-Z] | [0-9] | '+' | '/' | '=' )*
      * </pre>
      * 
      * @param pos The position in the Schema
      * @return The ByteCode
      */
     private static String getByteCode( PosSchema pos )
     {
         if ( ( pos.line == null ) || ( pos.line.length() - pos.start < 1 ) )
         {
             return "";
         }
 
         int start = pos.start;
         
         
         while ( !isEmpty( pos ) && ( isAlpha( pos ) || isDigit( pos ) || startsWith( pos, PLUS ) 
             || startsWith( pos, SLASH ) || startsWith( pos, EQUAL ) ) )
         {
             pos.start++;
             
             if ( ( pos.line == null ) || ( pos.line.length() - pos.start < 1 ) )
             {
                 return pos.line.substring( start, pos.start );
             }
         }
         
         return pos.line.substring( start, pos.start );
     }
     
     
     /**
      * 
      * @param elementsSeen The elements that have been processed already
      * @param element The current element
      * @param pos T he position in the Schema
      * @return The elements we have just processed
      * @throws LdapSchemaException If the schema is wrong
      */
     private static int checkElement( int elementsSeen, SchemaObjectElements element, PosSchema pos ) throws LdapSchemaException
     {
         if ( ( elementsSeen & element.getValue() ) != 0 )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13780_SCHEMA_OBJECT_DESCRIPTION_HAS_ELEMENT_TWICE, 
                 element, pos.lineNumber, pos.start ) );
         }
         
         elementsSeen |= element.getValue();
         
         return elementsSeen;
     }
 
     
     /**
      * Production for matching attribute type descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * AttributeTypeDescription = LPAREN WSP
      *     numericoid                    ; object identifier
      *     [ SP "NAME" SP qdescrs ]      ; short names (descriptors)
      *     [ SP "DESC" SP qdstring ]     ; description
      *     [ SP "OBSOLETE" ]             ; not active
      *     [ SP "SUP" SP oid ]           ; supertype
      *     [ SP "EQUALITY" SP oid ]      ; equality matching rule
      *     [ SP "ORDERING" SP oid ]      ; ordering matching rule
      *     [ SP "SUBSTR" SP oid ]        ; substrings matching rule
      *     [ SP "SYNTAX" SP noidlen ]    ; value syntax
      *     [ SP "SINGLE-VALUE" ]         ; single-value
      *     [ SP "COLLECTIVE" ]           ; collective
      *     [ SP "NO-USER-MODIFICATION" ] ; not user modifiable
      *     [ SP "USAGE" SP usage ]       ; usage
      *     extensions WSP RPAREN         ; extensions
      * 
      * usage = "userApplications"     /  ; user
      *         "directoryOperation"   /  ; directory operational
      *         "distributedOperation" /  ; DSA-shared operational
      *         "dSAOperation"            ; DSA-specific operational     
      * 
      * extensions = *( SP xstring SP qdstrings )
      * xstring = "X" HYPHEN 1*( ALPHA / HYPHEN / USCORE ) 
      * </pre>
      * 
      * @param attributeTypeDescription The String containing the AttributeTypeDescription
      * @return An instance of AttributeType
      * @throws ParseException If the element was invalid
      */
     public AttributeType parseAttributeType( String attributeTypeDescription ) throws ParseException
     {
         if ( ( attributeTypeDescription == null ) || Strings.isEmpty( attributeTypeDescription.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( attributeTypeDescription ) ) )
         {
             PosSchema pos = new PosSchema();
 
             if ( isQuirksModeEnabled )
             {
                 return parseAttributeTypeRelaxed( reader, pos, objectIdentifierMacros );
             }
             else
             {
                 return parseAttributeTypeStrict( reader, pos, objectIdentifierMacros );
             }
         }
         catch ( IOException | LdapSchemaException e )
         {
             // This exception is not passed as a cause in ParseException. Therefore at least log in, so it won't be lost.
             LOG.trace( I18n.err( I18n.ERR_13865_ERROR_PARSING_AT, attributeTypeDescription, e.getMessage() ), e );
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
     
     /**
      * Production for matching attribute type descriptions. It is fault-tolerant
      * against element ordering. It's strict.
      *
      * <pre>
      * AttributeTypeDescription = LPAREN WSP
      *     numericoid                    ; object identifier
      *     [ SP "NAME" SP qdescrs ]      ; short names (descriptors)
      *     [ SP "DESC" SP qdstring ]     ; description
      *     [ SP "OBSOLETE" ]             ; not active
      *     [ SP "SUP" SP oid ]           ; supertype
      *     [ SP "EQUALITY" SP oid ]      ; equality matching rule
      *     [ SP "ORDERING" SP oid ]      ; ordering matching rule
      *     [ SP "SUBSTR" SP oid ]        ; substrings matching rule
      *     [ SP "SYNTAX" SP noidlen ]    ; value syntax
      *     [ SP "SINGLE-VALUE" ]         ; single-value
      *     [ SP "COLLECTIVE" ]           ; collective
      *     [ SP "NO-USER-MODIFICATION" ] ; not user modifiable
      *     [ SP "USAGE" SP usage ]       ; usage
      *     extensions WSP RPAREN         ; extensions
      * 
      * usage = "userApplications"     /  ; user
      *         "directoryOperation"   /  ; directory operational
      *         "distributedOperation" /  ; DSA-shared operational
      *         "dSAOperation"            ; DSA-specific operational     
      * 
      * extensions = *( SP xstring SP qdstrings )
      * xstring = "X" HYPHEN 1*( ALPHA / HYPHEN / USCORE ) 
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of AttributeType
      * @throws IOException If the stream can't be read
      * @throws LdapSchemaException If the schema is wrong
      */
     private static AttributeType parseAttributeTypeStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         // Check that the OID is valid
         if ( !Oid.isOid( oid ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
         
         AttributeType attributeType = new AttributeType( oid );
         boolean hasSup = false;
         boolean hasSyntax = false;
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
 
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.NAME, pos );
                 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 attributeType.setNames( getQDescrs( reader, pos, STRICT ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 attributeType.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.OBSOLETE, pos );
                 
                 pos.start += OBSOLETE_STR.length();
                 
                 attributeType.setObsolete( true );
             }
             else if ( startsWith( pos, SUP_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.SUP, pos );
                 
                 pos.start += SUP_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String superiorOid = getOidStrict( pos );
 
                 attributeType.setSuperiorOid( superiorOid );
                 hasSup = true;
             }
             else if ( startsWith( pos, EQUALITY_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.EQUALITY, pos );
                 
                 pos.start += EQUALITY_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String equalityOid = getOidStrict( pos );
 
                 attributeType.setEqualityOid( equalityOid );
             }
             else if ( startsWith( pos, ORDERING_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.ORDERING, pos );
                 
                 pos.start += ORDERING_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String orderingOid = getOidStrict( pos );
 
                 attributeType.setOrderingOid( orderingOid );
             }
             else if ( startsWith( pos, SUBSTR_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.SUBSTR, pos );
 
                 pos.start += SUBSTR_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String substrOid = getOidStrict( pos );
 
                 attributeType.setSubstringOid( substrOid );
             }
             else if ( startsWith( pos, SYNTAX_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.SYNTAX, pos );
                 
                 pos.start += SYNTAX_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 getNoidLenStrict( attributeType, pos );
 
                 hasSyntax = true;
             }
             else if ( startsWith( pos, SINGLE_VALUE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.SINGLE_VALUE, pos );
                 
                 pos.start += SINGLE_VALUE_STR.length();
                 
                 attributeType.setSingleValued( true );
             }
             else if ( startsWith( pos, COLLECTIVE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.COLLECTIVE, pos );
                 
                 pos.start += COLLECTIVE_STR.length();
                 
                 attributeType.setCollective( true );
             }
             else if ( startsWith( pos, NO_USER_MODIFICATION_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.NO_USER_MODIFICATION, pos );
                 
                 pos.start += NO_USER_MODIFICATION_STR.length();
                 
                 attributeType.setUserModifiable( false );
             }
             else if ( startsWith( pos, USAGE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.USAGE, pos );
                 
                 pos.start += USAGE_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 UsageEnum usage = getUsageStrict( pos );
 
                 attributeType.setUsage( usage );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, attributeType );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13798_AT_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         // Semantic checks
         if ( !hasSup && !hasSyntax )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13799_SYNTAX_OR_SUP_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         if ( attributeType.isCollective() && ( attributeType.getUsage() != UsageEnum.USER_APPLICATIONS ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13800_COLLECTIVE_REQUIRES_USER_APPLICATION, 
                 pos.lineNumber, pos.start ) );
         }
     
         // NO-USER-MODIFICATION requires an operational USAGE.
         if ( !attributeType.isUserModifiable() && ( attributeType.getUsage() == UsageEnum.USER_APPLICATIONS ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13801_NO_USER_MOD_REQUIRE_OPERATIONAL, 
                 pos.lineNumber, pos.start ) );
         }
         
         return attributeType;
     }
     
     
     /**
      * Production for matching attribute type descriptions. It is fault-tolerant
      * against element ordering. It's relaxed.
      *
      * <pre>
      * AttributeTypeDescription = LPAREN WSP
      *     numericoid                    ; object identifier
      *     [ SP "NAME" SP qdescrs ]      ; short names (descriptors)
      *     [ SP "DESC" SP qdstring ]     ; description
      *     [ SP "OBSOLETE" ]             ; not active
      *     [ SP "SUP" SP oid ]           ; supertype
      *     [ SP "EQUALITY" SP oid ]      ; equality matching rule
      *     [ SP "ORDERING" SP oid ]      ; ordering matching rule
      *     [ SP "SUBSTR" SP oid ]        ; substrings matching rule
      *     [ SP "SYNTAX" SP noidlen ]    ; value syntax
      *     [ SP "SINGLE-VALUE" ]         ; single-value
      *     [ SP "COLLECTIVE" ]           ; collective
      *     [ SP "NO-USER-MODIFICATION" ] ; not user modifiable
      *     [ SP "USAGE" SP usage ]       ; usage
      *     extensions WSP RPAREN         ; extensions
      * 
      * usage = "userApplications"     /  ; user
      *         "directoryOperation"   /  ; directory operational
      *         "distributedOperation" /  ; DSA-shared operational
      *         "dSAOperation"            ; DSA-specific operational     
      * 
      * extensions = *( SP xstring SP qdstrings )
      * xstring = "X" HYPHEN 1*( ALPHA / HYPHEN / USCORE ) 
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of AttributeType
      * @throws IOException If the stream can't be read
      * @throws LdapSchemaException If the schema is wrong
      */
     private static AttributeType parseAttributeTypeRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         AttributeType attributeType = new AttributeType( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             // Make whitespace non-mandatory here.
             // E.g. OpenDJ is missing the the space in some schema definitions.
             skipWhites( reader, pos, false );
 
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.NAME, pos );
                 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 attributeType.setNames( getQDescrs( reader, pos, RELAXED ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 attributeType.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.OBSOLETE, pos );
                 
                 pos.start += OBSOLETE_STR.length();
                 
                 attributeType.setObsolete( true );
             }
             else if ( startsWith( pos, SUP_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.SUP, pos );
                 
                 pos.start += SUP_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String superiorOid = getOidRelaxed( pos, false );
 
                 attributeType.setSuperiorOid( superiorOid );
             }
             else if ( startsWith( pos, EQUALITY_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.EQUALITY, pos );
                 
                 pos.start += EQUALITY_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String equalityOid = getOidRelaxed( pos, false );
 
                 attributeType.setEqualityOid( equalityOid );
             }
             else if ( startsWith( pos, ORDERING_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.ORDERING, pos );
                 
                 pos.start += ORDERING_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String orderingOid = getOidRelaxed( pos, false );
 
                 attributeType.setOrderingOid( orderingOid );
             }
             else if ( startsWith( pos, SUBSTR_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.SUBSTR, pos );
 
                 pos.start += SUBSTR_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String substrOid = getOidRelaxed( pos, false );
 
                 attributeType.setSubstringOid( substrOid );
             }
             else if ( startsWith( pos, SYNTAX_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.SYNTAX, pos );
                 
                 pos.start += SYNTAX_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 getNoidLenRelaxed( attributeType, pos );
             }
             else if ( startsWith( pos, SINGLE_VALUE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.SINGLE_VALUE, pos );
                 
                 pos.start += SINGLE_VALUE_STR.length();
                 
                 attributeType.setSingleValued( true );
             }
             else if ( startsWith( pos, COLLECTIVE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.COLLECTIVE, pos );
                 
                 pos.start += COLLECTIVE_STR.length();
                 
                 attributeType.setCollective( true );
             }
             else if ( startsWith( pos, NO_USER_MODIFICATION_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.NO_USER_MODIFICATION, pos );
                 
                 pos.start += NO_USER_MODIFICATION_STR.length();
                 
                 attributeType.setUserModifiable( false );
             }
             else if ( startsWith( pos, USAGE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, AttributeTypeElements.USAGE, pos );
                 
                 pos.start += USAGE_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 UsageEnum usage = getUsageRelaxed( pos );
 
                 attributeType.setUsage( usage );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, attributeType );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13798_AT_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         return attributeType;
     }
 
     
     /**
      * Production for matching DitContentRule descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * DITContentRuleDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    [ SP "AUX" SP oids ]       ; auxiliary object classes
      *    [ SP "MUST" SP oids ]      ; attribute types
      *    [ SP "MAY" SP oids ]       ; attribute types
      *    [ SP "NOT" SP oids ]       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param ditContentRuleDescription The String containing the DitContentRuleDescription
      * @return An instance of ditContentRule
      * @throws ParseException If the element was invalid
      */
     public DitContentRule parseDitContentRule( String ditContentRuleDescription ) throws ParseException
     {
         if ( ( ditContentRuleDescription == null ) || Strings.isEmpty( ditContentRuleDescription.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( ditContentRuleDescription ) ) )
         {
             PosSchema pos = new PosSchema();
 
             if ( isQuirksModeEnabled )
             {
                 return parseDitContentRuleRelaxed( reader, pos, objectIdentifierMacros );
             }
             else
             {
                 return parseDitContentRuleStrict( reader, pos, objectIdentifierMacros );
             }
         }
         catch ( IOException | LdapSchemaException e )
         {
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
     
     /**
      * Production for DitContentRule descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * DITContentRuleDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    [ SP "AUX" SP oids ]       ; auxiliary object classes
      *    [ SP "MUST" SP oids ]      ; attribute types
      *    [ SP "MAY" SP oids ]       ; attribute types
      *    [ SP "NOT" SP oids ]       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of DitContentRule
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static DitContentRule parseDitContentRuleStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         // Check that the OID is valid
         if ( !Oid.isOid( oid ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
         
         DitContentRule ditContentRule = new DitContentRule( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
             
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ditContentRule.setNames( getQDescrs( reader, pos, STRICT ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ditContentRule.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.OBSOLETE, pos );
 
                 pos.start += OBSOLETE_STR.length();
                 
                 ditContentRule.setObsolete( true );
             }
             else if ( startsWith( pos, AUX_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.AUX, pos );
 
                 pos.start += AUX_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> aux = getOidsStrict( reader, pos );
                 
                 ditContentRule.setAuxObjectClassOids( aux );
             }
             else if ( startsWith( pos, MUST_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.MUST, pos );
 
                 pos.start += MUST_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> must = getOidsStrict( reader, pos );
                 
                 ditContentRule.setMustAttributeTypeOids( must );
             }
             else if ( startsWith( pos, MAY_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.MAY, pos );
 
                 pos.start += MAY_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> may = getOidsStrict( reader, pos );
                 
                 ditContentRule.setMayAttributeTypeOids( may );
             }
             else if ( startsWith( pos, NOT_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.NOT, pos );
 
                 pos.start += NOT_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> not = getOidsStrict( reader, pos );
                 
                 ditContentRule.setNotAttributeTypeOids( not );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, ditContentRule );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
 
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13809_DCR_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         return ditContentRule;
     }
 
     
     /**
      * Production for DitContentRule descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * DITContentRuleDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    [ SP "AUX" SP oids ]       ; auxiliary object classes
      *    [ SP "MUST" SP oids ]      ; attribute types
      *    [ SP "MAY" SP oids ]       ; attribute types
      *    [ SP "NOT" SP oids ]       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of DitContentRule
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static DitContentRule parseDitContentRuleRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         // Now, the OID. 
         
         DitContentRule ditContentRule = new DitContentRule( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
 
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ditContentRule.setNames( getQDescrs( reader, pos, RELAXED ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ditContentRule.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.OBSOLETE, pos );
 
                 pos.start += OBSOLETE_STR.length();
                 
                 ditContentRule.setObsolete( true );
             }
             else if ( startsWith( pos, AUX_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.AUX, pos );
 
                 pos.start += AUX_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> aux = getOidsRelaxed( reader, pos );
                 
                 ditContentRule.setAuxObjectClassOids( aux );
             }
             else if ( startsWith( pos, MUST_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.MUST, pos );
 
                 pos.start += MUST_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> must = getOidsRelaxed( reader, pos );
                 
                 ditContentRule.setMustAttributeTypeOids( must );
             }
             else if ( startsWith( pos, MAY_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.MAY, pos );
 
                 pos.start += MAY_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> may = getOidsRelaxed( reader, pos );
                 
                 ditContentRule.setMayAttributeTypeOids( may );
             }
             else if ( startsWith( pos, NOT_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitContentRuleElements.NOT, pos );
 
                 pos.start += NOT_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> not = getOidsRelaxed( reader, pos );
                 
                 ditContentRule.setNotAttributeTypeOids( not );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, ditContentRule );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
 
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13809_DCR_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         return ditContentRule;
     }
 
     
     /**
      * Production for matching DitStructureRule descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * DITStructureRuleDescription = LPAREN WSP
      *   ruleid                     ; rule identifier
      *   [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *   [ SP "DESC" SP qdstring ]  ; description
      *   [ SP "OBSOLETE" ]          ; not active
      *   SP "FORM" SP oid           ; NameForm
      *   [ SP "SUP" ruleids ]       ; superior rules
      *   extensions WSP RPAREN      ; extensions
      *
      * ruleids = ruleid / ( LPAREN WSP ruleidlist WSP RPAREN )
      * ruleidlist = ruleid *( SP ruleid )
      * ruleid = number
      * </pre>
      * 
      * @param ditStructureRuleDescription The String containing the DitStructureRuleDescription
      * @return An instance of DitStructureRule
      * @throws ParseException If the element was invalid
      */
     public DitStructureRule parseDitStructureRule( String ditStructureRuleDescription ) throws ParseException
     {
         if ( ( ditStructureRuleDescription == null ) || Strings.isEmpty( ditStructureRuleDescription.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( ditStructureRuleDescription ) ) )
         {
             PosSchema pos = new PosSchema();
 
             if ( isQuirksModeEnabled )
             {
                 return parseDitStructureRuleRelaxed( reader, pos, objectIdentifierMacros );
             }
             else
             {
                 return parseDitStructureRuleStrict( reader, pos );
             }
         }
         catch ( IOException | LdapSchemaException e )
         {
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
     
     /**
      * Production for DitStructureRule descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * DITStructureRuleDescription = LPAREN WSP
      *   ruleid                     ; rule identifier
      *   [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *   [ SP "DESC" SP qdstring ]  ; description
      *   [ SP "OBSOLETE" ]          ; not active
      *   SP "FORM" SP oid           ; NameForm
      *   [ SP "SUP" ruleids ]       ; superior rules
      *   extensions WSP RPAREN      ; extensions
      *
      * ruleids = ruleid / ( LPAREN WSP ruleidlist WSP RPAREN )
      * ruleidlist = ruleid *( SP ruleid )
      * ruleid = number
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @return An instance of DitStructureRule
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static DitStructureRule parseDitStructureRuleStrict( Reader reader, PosSchema pos ) 
         throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the ruleID. 
         int ruleId = getRuleId( pos );
         
         DitStructureRule ditStructureRule = new DitStructureRule( ruleId );
         int elementsSeen = 0;
         boolean hasForm = false;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
             
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitStructureRuleElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ditStructureRule.setNames( getQDescrs( reader, pos, STRICT ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitStructureRuleElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ditStructureRule.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitStructureRuleElements.OBSOLETE, pos );
 
                 pos.start += OBSOLETE_STR.length();
                 
                 ditStructureRule.setObsolete( true );
             }
             else if ( startsWith( pos, FORM_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitStructureRuleElements.FORM, pos );
 
                 pos.start += FORM_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String form = getOidStrict( pos );
                 
                 ditStructureRule.setForm( form );
                 hasForm = true;
             }
             else if ( startsWith( pos, SUP_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitStructureRuleElements.SUP, pos );
 
                 pos.start += SUP_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<Integer> superRules = getRuleIds( reader, pos );
                 
                 ditStructureRule.setSuperRules( superRules );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, ditStructureRule );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13809_DCR_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         // Semantic checks
         if ( !hasForm )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13812_FORM_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         return ditStructureRule;
     }
 
     
     /**
      * Production for DitStructureRule descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * DITStructureRuleDescription = LPAREN WSP
      *   ruleid                     ; rule identifier
      *   [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *   [ SP "DESC" SP qdstring ]  ; description
      *   [ SP "OBSOLETE" ]          ; not active
      *   SP "FORM" SP oid           ; NameForm
      *   [ SP "SUP" ruleids ]       ; superior rules
      *   extensions WSP RPAREN      ; extensions
      *
      * ruleids = ruleid / ( LPAREN WSP ruleidlist WSP RPAREN )
      * ruleidlist = ruleid *( SP ruleid )
      * ruleid = number
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of DitStructureRule
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static DitStructureRule parseDitStructureRuleRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
             throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the ruleID. 
         int ruleId = getRuleId( pos );
         
         DitStructureRule ditStructureRule = new DitStructureRule( ruleId );
         int elementsSeen = 0;
         boolean hasForm = false;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
             
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitStructureRuleElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ditStructureRule.setNames( getQDescrs( reader, pos, RELAXED ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitStructureRuleElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ditStructureRule.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitStructureRuleElements.OBSOLETE, pos );
 
                 pos.start += OBSOLETE_STR.length();
                 
                 ditStructureRule.setObsolete( true );
             }
             else if ( startsWith( pos, FORM_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitStructureRuleElements.FORM, pos );
 
                 pos.start += FORM_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String form = getOidRelaxed( pos, UN_QUOTED );
                 
                 ditStructureRule.setForm( form );
                 hasForm = true;
             }
             else if ( startsWith( pos, SUP_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, DitStructureRuleElements.SUP, pos );
 
                 pos.start += SUP_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<Integer> superRules = getRuleIds( reader, pos );
                 
                 ditStructureRule.setSuperRules( superRules );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, ditStructureRule );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13809_DCR_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
 
         if ( !hasForm )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13812_FORM_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         return ditStructureRule;
     }
 
     
     /**
      * Production for LdapComparator descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * LdapComparatorDescription = LPAREN WSP
      *       numericoid                           ; object identifier
      *       [ SP "DESC" SP qdstring ]            ; description
      *       SP "FQCN" SP fqcn                    ; fully qualified class name
      *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
      *       extensions WSP RPAREN                ; extensions
      * 
      * base64          = *(4base64-char)
      * base64-char     = ALPHA / DIGIT / "+" / "/"
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
      * 
      * @param ldapComparatorDescription The String containing the LdapComparatorDescription
      * @return An instance of LdapComparatorDescription
      * @throws ParseException If the element was invalid
      */
     public LdapComparatorDescription parseLdapComparator( String ldapComparatorDescription ) throws ParseException
     {
         if ( ( ldapComparatorDescription == null ) || Strings.isEmpty( ldapComparatorDescription.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( ldapComparatorDescription ) ) )
         {
             PosSchema pos = new PosSchema();
 
             if ( isQuirksModeEnabled )
             {
                 return parseLdapComparatorRelaxed( reader, pos, objectIdentifierMacros );
             }
             else
             {
                 return parseLdapComparatorStrict( reader, pos, objectIdentifierMacros );
             }
         }
         catch ( IOException | LdapSchemaException e )
         {
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
     
     /**
      * Production for LdapComparator descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * LdapComparatorDescription = LPAREN WSP
      *       numericoid                           ; object identifier
      *       [ SP "DESC" SP qdstring ]            ; description
      *       SP "FQCN" SP fqcn                    ; fully qualified class name
      *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
      *       extensions WSP RPAREN                ; extensions
      * 
      * base64          = *(4base64-char)
      * base64-char     = ALPHA / DIGIT / "+" / "/"
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of LdapComparatorDescription
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static LdapComparatorDescription parseLdapComparatorStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         // Check that the OID is valid
         if ( !Oid.isOid( oid ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
         
         LdapComparatorDescription ldapComparator = new LdapComparatorDescription( oid );
         int elementsSeen = 0;
         boolean hasFqcn = false;
         boolean hasByteCode = false;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
             
             if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, LdapComparatorElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ldapComparator.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, FQCN_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, LdapComparatorElements.FQCN, pos );
 
                 pos.start += FQCN_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 String fqcn = getFqcn( pos );
                 ldapComparator.setFqcn( fqcn );
                 hasFqcn = true;
             }
             else if ( startsWith( pos, BYTECODE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, LdapComparatorElements.BYTECODE, pos );
 
                 pos.start += BYTECODE_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String byteCode = getByteCode( pos );
                 ldapComparator.setBytecode( byteCode );
                 hasByteCode = true;
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, ldapComparator );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13825_COMP_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         // Semantic checks
         if ( !hasFqcn )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13819_FQCN_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         if ( ( hasByteCode ) && ( ldapComparator.getBytecode().length() % 4 != 0 ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13820_BYTE_CODE_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         return ldapComparator;
     }
 
     
     /**
      * Production for LdapComparator descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * LdapComparatorDescription = LPAREN WSP
      *       numericoid                           ; object identifier
      *       [ SP "DESC" SP qdstring ]            ; description
      *       SP "FQCN" SP fqcn                    ; fully qualified class name
      *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
      *       extensions WSP RPAREN                ; extensions
      * 
      * base64          = *(4base64-char)
      * base64-char     = ALPHA / DIGIT / "+" / "/"
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of LdapComparatorDescription
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static LdapComparatorDescription parseLdapComparatorRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
             throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         LdapComparatorDescription ldapComparator = new LdapComparatorDescription( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
             
             if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, LdapComparatorElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ldapComparator.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, FQCN_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, LdapComparatorElements.FQCN, pos );
 
                 pos.start += FQCN_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 String fqcn = getFqcn( pos );
                 ldapComparator.setFqcn( fqcn );
             }
             else if ( startsWith( pos, BYTECODE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, LdapComparatorElements.BYTECODE, pos );
 
                 pos.start += BYTECODE_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String byteCode = getByteCode( pos );
                 ldapComparator.setBytecode( byteCode );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, ldapComparator );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13825_COMP_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
 
         return ldapComparator;
     }
 
     
     /**
      * Production for matching ldap syntax descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * SyntaxDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "DESC" SP qdstring ]  ; description
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param ldapSyntaxDescription The String containing the Ldap Syntax description
      * @return An instance of LdapSyntax
      * @throws ParseException If the element was invalid
      */
     public LdapSyntax parseLdapSyntax( String ldapSyntaxDescription ) throws ParseException
     {
         if ( ( ldapSyntaxDescription == null ) || Strings.isEmpty( ldapSyntaxDescription.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( ldapSyntaxDescription ) ) )
         {
             PosSchema pos = new PosSchema();
 
             if ( isQuirksModeEnabled )
             {
                 return parseLdapSyntaxRelaxed( reader, pos, objectIdentifierMacros );
             }
             else
             {
                 return parseLdapSyntaxStrict( reader, pos, objectIdentifierMacros );
             }
         }
         catch ( IOException | LdapSchemaException e )
         {
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
     
     /**
      * Production for matching ldap syntax descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * SyntaxDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "DESC" SP qdstring ]  ; description
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of LdapSyntax
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static LdapSyntax parseLdapSyntaxStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         // Check that the OID is valid
         if ( !Oid.isOid( oid ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
         
         LdapSyntax ldapSyntax = new LdapSyntax( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
             
             if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, LdapSyntaxElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ldapSyntax.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, ldapSyntax );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13807_SYN_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         return ldapSyntax;
     }
 
     
     /**
      * Production for matching ldap syntax descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * SyntaxDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "DESC" SP qdstring ]  ; description
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of LdapSyntax
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static LdapSyntax parseLdapSyntaxRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         LdapSyntax ldapSyntax = new LdapSyntax( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
             
             if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, LdapSyntaxElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 ldapSyntax.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, ldapSyntax );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13807_SYN_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         return ldapSyntax;
     }
     
     
     /**
      * Production for matching MatchingRule descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * MatchingRuleDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    SP "SYNTAX" SP numericoid  ; assertion syntax
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param matchingRuleDescription The String containing the MatchingRuledescription
      * @return An instance of MatchingRule
      * @throws ParseException If the element was invalid
      */
     public MatchingRule parseMatchingRule( String matchingRuleDescription ) throws ParseException
     {
         if ( ( matchingRuleDescription == null ) || Strings.isEmpty( matchingRuleDescription.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( matchingRuleDescription ) ) )
         {
             PosSchema pos = new PosSchema();
 
             if ( isQuirksModeEnabled )
             {
                 return parseMatchingRuleRelaxed( reader, pos, objectIdentifierMacros );
             }
             else
             {
                 return parseMatchingRuleStrict( reader, pos, objectIdentifierMacros );
             }
         }
         catch ( IOException | LdapSchemaException e )
         {
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
     
     /**
      * Production for matching rule descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * MatchingRuleDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    SP "SYNTAX" SP numericoid  ; assertion syntax
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of MatchingRule
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static MatchingRule parseMatchingRuleStrict( Reader reader, PosSchema pos, 
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         // Check that the OID is valid
         if ( !Oid.isOid( oid ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
         
         MatchingRule matchingRule = new MatchingRule( oid );
         int elementsSeen = 0;
         boolean hasSyntax = false;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
             
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 matchingRule.setNames( getQDescrs( reader, pos, STRICT ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 matchingRule.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleElements.OBSOLETE, pos );
 
                 pos.start += OBSOLETE_STR.length();
                 
                 matchingRule.setObsolete( true );
             }
             else if ( startsWith( pos, SYNTAX_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleElements.SYNTAX, pos );
 
                 pos.start += SYNTAX_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String syntaxOid = getNumericOid( pos );
 
                 matchingRule.setSyntaxOid( syntaxOid );
                 hasSyntax = true;
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, matchingRule );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13781_MR_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         // Semantic checks
         if ( !hasSyntax )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13808_SYNTAX_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         return matchingRule;
     }
 
     
     /**
      * Production for matching rule descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * MatchingRuleDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    SP "SYNTAX" SP numericoid  ; assertion syntax
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of MatchingRule
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static MatchingRule parseMatchingRuleRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
             throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         MatchingRule matchingRule = new MatchingRule( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
             
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 matchingRule.setNames( getQDescrs( reader, pos, RELAXED ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 matchingRule.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleElements.OBSOLETE, pos );
 
                 pos.start += OBSOLETE_STR.length();
                 
                 matchingRule.setObsolete( true );
             }
             else if ( startsWith( pos, SYNTAX_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleElements.SYNTAX, pos );
 
                 pos.start += SYNTAX_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String syntaxOid = getNumericOid( pos );
 
                 matchingRule.setSyntaxOid( syntaxOid );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, matchingRule );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13781_MR_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
 
         return matchingRule;
     }
 
     
     /**
      * Production for matching MatchingRuleUse descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * MatchingRuleUseDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    SP "APPLIES" SP oids       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param matchingRuleUseDescription The String containing the MatchingRuleUsedescription
      * @return An instance of MatchingRuleUse
      * @throws ParseException If the element was invalid
      */
     public MatchingRuleUse parseMatchingRuleUse( String matchingRuleUseDescription ) throws ParseException
     {
         if ( ( matchingRuleUseDescription == null ) || Strings.isEmpty( matchingRuleUseDescription.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( matchingRuleUseDescription ) ) )
         {
             PosSchema pos = new PosSchema();
 
             if ( isQuirksModeEnabled )
             {
                 return parseMatchingRuleUseRelaxed( reader, pos, objectIdentifierMacros );
             }
             else
             {
                 return parseMatchingRuleUseStrict( reader, pos, objectIdentifierMacros );
             }
         }
         catch ( IOException | LdapSchemaException e )
         {
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
     
     /**
      * Production for MatchingRuleUse descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * MatchingRuleUseDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    SP "APPLIES" SP oids       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of MatchingRuleUse
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static MatchingRuleUse parseMatchingRuleUseStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         // Check that the OID is valid
         if ( !Oid.isOid( oid ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
         
         MatchingRuleUse matchingRuleUse = new MatchingRuleUse( oid );
         int elementsSeen = 0;
         boolean hasApplies = false;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, false );
             
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleUseElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 matchingRuleUse.setNames( getQDescrs( reader, pos, STRICT ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleUseElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 matchingRuleUse.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleUseElements.OBSOLETE, pos );
 
                 pos.start += OBSOLETE_STR.length();
                 
                 matchingRuleUse.setObsolete( true );
             }
             else if ( startsWith( pos, APPLIES_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleUseElements.APPLIES, pos );
 
                 pos.start += APPLIES_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> oids = getOidsStrict( reader, pos );
 
                 matchingRuleUse.setApplicableAttributeOids( oids );
                 hasApplies = true;
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, matchingRuleUse );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13815_MRU_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         // Semantic checks
         if ( !hasApplies )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13814_APPLIES_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         return matchingRuleUse;
     }
 
     
     /**
      * Production for MatchingRuleUse descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * MatchingRuleUseDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    SP "APPLIES" SP oids       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of MatchingRuleUse
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static MatchingRuleUse parseMatchingRuleUseRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
             throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         MatchingRuleUse matchingRuleUse = new MatchingRuleUse( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
             
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleUseElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 matchingRuleUse.setNames( getQDescrs( reader, pos, RELAXED ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleUseElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 matchingRuleUse.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleUseElements.OBSOLETE, pos );
 
                 pos.start += OBSOLETE_STR.length();
                 
                 matchingRuleUse.setObsolete( true );
             }
             else if ( startsWith( pos, APPLIES_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, MatchingRuleUseElements.APPLIES, pos );
 
                 pos.start += APPLIES_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> oids = getOidsRelaxed( reader, pos );
 
                 matchingRuleUse.setApplicableAttributeOids( oids );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, matchingRuleUse );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13815_MRU_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
 
         return matchingRuleUse;
     }
 
     
     /**
      * Production for NameForm descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * NameFormDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    SP "OC" SP oid             ; structural object class
      *    SP "MUST" SP oids          ; attribute types
      *    [ SP "MAY" SP oids ]       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param nameFormDescription The String containing the NameFormdescription
      * @return An instance of NameForm
      * @throws ParseException If the element was invalid
      */
     public NameForm parseNameForm( String nameFormDescription ) throws ParseException
     {
         if ( ( nameFormDescription == null ) || Strings.isEmpty( nameFormDescription.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( nameFormDescription ) ) )
         {
             PosSchema pos = new PosSchema();
 
             if ( isQuirksModeEnabled )
             {
                 return parseNameFormRelaxed( reader, pos, objectIdentifierMacros );
             }
             else
             {
                 return parseNameFormStrict( reader, pos, objectIdentifierMacros );
             }
         }
         catch ( IOException | LdapSchemaException e )
         {
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
     
     /**
      * Production for NameForm descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * NameFormDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    SP "OC" SP oid             ; structural object class
      *    SP "MUST" SP oids          ; attribute types
      *    [ SP "MAY" SP oids ]       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @return An instance of NameForm
      * @param objectIdentifierMacros The set of existing Macros
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static NameForm parseNameFormStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         // Check that the OID is valid
         if ( !Oid.isOid( oid ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
         
         NameForm nameForm = new NameForm( oid );
         int elementsSeen = 0;
         boolean hasOc = false;
         boolean hasMust = false;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
 
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 nameForm.setNames( getQDescrs( reader, pos, STRICT ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 nameForm.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.OBSOLETE, pos );
 
                 pos.start += OBSOLETE_STR.length();
                 
                 nameForm.setObsolete( true );
             }
             else if ( startsWith( pos, OC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.OC, pos );
 
                 pos.start += OC_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String oc = getOidStrict( pos );
 
                 nameForm.setStructuralObjectClassOid( oc );
                 hasOc = true;
             }
             else if ( startsWith( pos, MUST_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.MUST, pos );
 
                 pos.start += MUST_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> must = getOidsStrict( reader, pos );
 
                 nameForm.setMustAttributeTypeOids( must );
                 hasMust = true;
             }
             else if ( startsWith( pos, MAY_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.MAY, pos );
 
                 pos.start += MAY_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> may = getOidsStrict( reader, pos );
 
                 nameForm.setMayAttributeTypeOids( may );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, nameForm );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13816_NF_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         // Semantic checks
         if ( !hasOc )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13817_STRUCTURAL_OBJECT_CLASS_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         if ( !hasMust )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13818_MUST_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         return nameForm;
     }
 
     
     /**
      * Production for NameForm descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * NameFormDescription = LPAREN WSP
      *    numericoid                 ; object identifier
      *    [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *    [ SP "DESC" SP qdstring ]  ; description
      *    [ SP "OBSOLETE" ]          ; not active
      *    SP "OC" SP oid             ; structural object class
      *    SP "MUST" SP oids          ; attribute types
      *    [ SP "MAY" SP oids ]       ; attribute types
      *    extensions WSP RPAREN      ; extensions
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of NameForm
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static NameForm parseNameFormRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
             throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         NameForm nameForm = new NameForm( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
 
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 nameForm.setNames( getQDescrs( reader, pos, RELAXED ) );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 nameForm.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.OBSOLETE, pos );
 
                 pos.start += OBSOLETE_STR.length();
                 
                 nameForm.setObsolete( true );
             }
             else if ( startsWith( pos, OC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.OC, pos );
 
                 pos.start += OC_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 String oc = getOidRelaxed( pos, UN_QUOTED );
 
                 nameForm.setStructuralObjectClassOid( oc );
             }
             else if ( startsWith( pos, MUST_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.MUST, pos );
 
                 pos.start += MUST_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> must = getOidsRelaxed( reader, pos );
 
                 nameForm.setMustAttributeTypeOids( must );
             }
             else if ( startsWith( pos, MAY_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NameFormElements.MAY, pos );
 
                 pos.start += MAY_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> may = getOidsRelaxed( reader, pos );
 
                 nameForm.setMayAttributeTypeOids( may );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, nameForm );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13816_NF_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         return nameForm;
     }
 
     
     /**
      * Production for Normalizer descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * NormalizerDescription = LPAREN WSP
      *       numericoid                           ; object identifier
      *       [ SP "DESC" SP qdstring ]            ; description
      *       SP "FQCN" SP fqcn                    ; fully qualified class name
      *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
      *       extensions WSP RPAREN                ; extensions
      * 
      * base64          = *(4base64-char)
      * base64-char     = ALPHA / DIGIT / "+" / "/"
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
      * 
      * @param normalizerDescription The String containing the NormalizerDescription
      * @return An instance of NormalizerDescription
      * @throws ParseException If the element was invalid
      */
     public NormalizerDescription parseNormalizer( String normalizerDescription ) throws ParseException
     {
         if ( ( normalizerDescription == null ) || Strings.isEmpty( normalizerDescription.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( normalizerDescription ) ) )
         {
             PosSchema pos = new PosSchema();
 
             if ( isQuirksModeEnabled )
             {
                 return parseNormalizerRelaxed( reader, pos, objectIdentifierMacros );
             }
             else
             {
                 return parseNormalizerStrict( reader, pos, objectIdentifierMacros );
             }
         }
         catch ( IOException | LdapSchemaException e )
         {
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
     
     /**
      * Production for Normalizer descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * NormalizerDescription = LPAREN WSP
      *       numericoid                           ; object identifier
      *       [ SP "DESC" SP qdstring ]            ; description
      *       SP "FQCN" SP fqcn                    ; fully qualified class name
      *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
      *       extensions WSP RPAREN                ; extensions
      * 
      * base64          = *(4base64-char)
      * base64-char     = ALPHA / DIGIT / "+" / "/"
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of NormalizerDescription
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static NormalizerDescription parseNormalizerStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         // Check that the OID is valid
         if ( !Oid.isOid( oid ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
         
         NormalizerDescription normalizer = new NormalizerDescription( oid );
         int elementsSeen = 0;
         boolean hasFqcn = false;
         boolean hasByteCode = false;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
 
             if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NormalizerElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 normalizer.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, FQCN_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NormalizerElements.FQCN, pos );
 
                 pos.start += FQCN_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 String fqcn = getFqcn( pos );
                 normalizer.setFqcn( fqcn );
                 hasFqcn = true;
             }
             else if ( startsWith( pos, BYTECODE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NormalizerElements.BYTECODE, pos );
 
                 pos.start += BYTECODE_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 String byteCode = getByteCode( pos );
                 normalizer.setBytecode( byteCode );
                 hasByteCode = true;
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, normalizer );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13821_NORM_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         // Semantic checks
         if ( !hasFqcn )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13819_FQCN_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         if ( ( hasByteCode ) && ( normalizer.getBytecode().length() % 4 != 0 ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13820_BYTE_CODE_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         return normalizer;
     }
 
     
     /**
      * Production for Normalizer descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * NormalizerDescription = LPAREN WSP
      *       numericoid                           ; object identifier
      *       [ SP "DESC" SP qdstring ]            ; description
      *       SP "FQCN" SP fqcn                    ; fully qualified class name
      *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
      *       extensions WSP RPAREN                ; extensions
      * 
      * base64          = *(4base64-char)
      * base64-char     = ALPHA / DIGIT / "+" / "/"
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of NormalizerDescription
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static NormalizerDescription parseNormalizerRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
             throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         NormalizerDescription normalizer = new NormalizerDescription( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
 
             if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NormalizerElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 normalizer.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, FQCN_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NormalizerElements.FQCN, pos );
 
                 pos.start += FQCN_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 String fqcn = getFqcn( pos );
                 normalizer.setFqcn( fqcn );
             }
             else if ( startsWith( pos, BYTECODE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, NormalizerElements.BYTECODE, pos );
 
                 pos.start += BYTECODE_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 String byteCode = getByteCode( pos );
                 normalizer.setBytecode( byteCode );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, normalizer );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13821_NORM_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         return normalizer;
     }
 
     
     /**
      * Production for matching ObjectClass descriptions. It is fault-tolerant
      * against element ordering.
      * 
      * <pre>
      * ObjectClassDescription = LPAREN WSP
      *   numericoid                 ; object identifier
      *   [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *   [ SP "DESC" SP qdstring ]  ; description
      *   [ SP "OBSOLETE" ]          ; not active
      *   [ SP "SUP" SP oids ]       ; superior object classes
      *   [ SP kind ]                ; kind of class
      *   [ SP "MUST" SP oids ]      ; attribute types
      *   [ SP "MAY" SP oids ]       ; attribute types
      *   extensions WSP RPAREN
      *
      *   kind = "ABSTRACT" / "STRUCTURAL" / "AUXILIARY"
      * </pre>
      * 
      * @param objectClassDescription The String containing the ObjectClassDescription
      * @return An instance of objectClass
      * @throws ParseException If the element was invalid
      */
     public ObjectClass parseObjectClass( String objectClassDescription ) throws ParseException
     {
         if ( ( objectClassDescription == null ) || Strings.isEmpty( objectClassDescription.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( objectClassDescription ) ) )
         {
             PosSchema pos = new PosSchema();
 
             if ( isQuirksModeEnabled )
             {
                 return parseObjectClassRelaxed( reader, pos, objectIdentifierMacros );
             }
             else
             {
                 return parseObjectClassStrict( reader, pos, objectIdentifierMacros );
             }
         }
         catch ( IOException | LdapSchemaException e )
         {
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
     
     /**
      * Production for matching ObjectClass descriptions. It is fault-tolerant
      * against element ordering.
      * <pre>
      * ObjectClassDescription = LPAREN WSP
      *   numericoid                 ; object identifier
      *   [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *   [ SP "DESC" SP qdstring ]  ; description
      *   [ SP "OBSOLETE" ]          ; not active
      *   [ SP "SUP" SP oids ]       ; superior object classes
      *   [ SP kind ]                ; kind of class
      *   [ SP "MUST" SP oids ]      ; attribute types
      *   [ SP "MAY" SP oids ]       ; attribute types
      *   extensions WSP RPAREN
      *
      *   kind = "ABSTRACT" / "STRUCTURAL" / "AUXILIARY"
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of ObjectClass
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static ObjectClass parseObjectClassStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
         throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the numeric OID
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         // Check that the OID is valid
         if ( !Oid.isOid( oid ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
 
         ObjectClass objectClass = new ObjectClass( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
 
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 List<String> names = getQDescrs( reader, pos, STRICT );
                 objectClass.setNames( names );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.DESC, pos );
                 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 objectClass.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.OBSOLETE, pos );
                 
                 pos.start += OBSOLETE_STR.length();
                 
                 objectClass.setObsolete( true );
             }
             else if ( startsWith( pos, SUP_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.SUP, pos );
                 
                 pos.start += SUP_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> superiorOids = getOidsStrict( reader, pos );
 
                 objectClass.setSuperiorOids( superiorOids );
             }
             else if ( startsWith( pos, ABSTRACT_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.ABSTRACT, pos );
                 
                 pos.start += ABSTRACT_STR.length();
                 
                 objectClass.setType( ObjectClassTypeEnum.ABSTRACT );
             }
             else if ( startsWith( pos, STRUCTURAL_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.STRUCTURAL, pos );
                 
                 pos.start += STRUCTURAL_STR.length();
                 
                 objectClass.setType( ObjectClassTypeEnum.STRUCTURAL );
             }
             else if ( startsWith( pos, AUXILIARY_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.AUXILIARY, pos );
                 
                 pos.start += AUXILIARY_STR.length();
                 
                 objectClass.setType( ObjectClassTypeEnum.AUXILIARY );
             }
             else if ( startsWith( pos, MUST_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.MUST, pos );
                 
                 pos.start += MUST_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> mustAttributeTypes = getOidsStrict( reader, pos );
                 objectClass.setMustAttributeTypeOids( mustAttributeTypes );
             }
             else if ( startsWith( pos, MAY_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.MAY, pos );
                 
                 pos.start += MAY_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> mayAttributeTypes = getOidsStrict( reader, pos );
                 objectClass.setMayAttributeTypeOids( mayAttributeTypes );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, objectClass );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13803_OC_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
 
         pos.start++;
         
         return objectClass;
     }
 
     
     /**
      * Production for matching ObjectClass descriptions. It is fault-tolerant
      * against element ordering.
      * <pre>
      * ObjectClassDescription = LPAREN WSP
      *   numericoid                 ; object identifier
      *   [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
      *   [ SP "DESC" SP qdstring ]  ; description
      *   [ SP "OBSOLETE" ]          ; not active
      *   [ SP "SUP" SP oids ]       ; superior object classes
      *   [ SP kind ]                ; kind of class
      *   [ SP "MUST" SP oids ]      ; attribute types
      *   [ SP "MAY" SP oids ]       ; attribute types
      *   extensions WSP RPAREN
      *
      *   kind = "ABSTRACT" / "STRUCTURAL" / "AUXILIARY"
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of ObjectClass
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static ObjectClass parseObjectClassRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
             throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the numeric OID
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         ObjectClass objectClass = new ObjectClass( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
 
             if ( startsWith( pos, NAME_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.NAME, pos );
 
                 pos.start += NAME_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 List<String> names = getQDescrs( reader, pos, RELAXED );
 
                 objectClass.setNames( names );
             }
             else if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.DESC, pos );
                 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 objectClass.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, OBSOLETE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.OBSOLETE, pos );
                 
                 pos.start += OBSOLETE_STR.length();
                 
                 objectClass.setObsolete( true );
             }
             else if ( startsWith( pos, SUP_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.SUP, pos );
                 
                 pos.start += SUP_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> superiorOids = getOidsRelaxed( reader, pos );
 
                 objectClass.setSuperiorOids( superiorOids );
             }
             else if ( startsWith( pos, ABSTRACT_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.ABSTRACT, pos );
                 
                 pos.start += ABSTRACT_STR.length();
                 
                 objectClass.setType( ObjectClassTypeEnum.ABSTRACT );
             }
             else if ( startsWith( pos, STRUCTURAL_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.STRUCTURAL, pos );
                 
                 pos.start += STRUCTURAL_STR.length();
                 
                 objectClass.setType( ObjectClassTypeEnum.STRUCTURAL );
             }
             else if ( startsWith( pos, AUXILIARY_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.AUXILIARY, pos );
                 
                 pos.start += AUXILIARY_STR.length();
                 
                 objectClass.setType( ObjectClassTypeEnum.AUXILIARY );
             }
             else if ( startsWith( pos, MUST_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.MUST, pos );
                 
                 pos.start += MUST_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> mustAttributeTypes = getOidsRelaxed( reader, pos );
                 objectClass.setMustAttributeTypeOids( mustAttributeTypes );
             }
             else if ( startsWith( pos, MAY_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, ObjectClassElements.MAY, pos );
                 
                 pos.start += MAY_STR.length();
                 
                 skipWhites( reader, pos, true );
                 
                 List<String> mayAttributeTypes = getOidsRelaxed( reader, pos );
                 objectClass.setMayAttributeTypeOids( mayAttributeTypes );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, objectClass );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13803_OC_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
 
         pos.start++;
         
         return objectClass;
     }
 
     
     /**
      * Production for SyntaxChecker descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * SyntaxCheckerDescription = LPAREN WSP
      *       numericoid                           ; object identifier
      *       [ SP "DESC" SP qdstring ]            ; description
      *       SP "FQCN" SP fqcn                    ; fully qualified class name
      *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
      *       extensions WSP RPAREN                ; extensions
      * 
      * base64          = *(4base64-char)
      * base64-char     = ALPHA / DIGIT / "+" / "/"
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
      * 
      * @param syntaxCheckerDescription The String containing the SyntaxCheckerDescription
      * @return An instance of SyntaxCheckerDescription
      * @throws ParseException If the element was invalid
      */
     public SyntaxCheckerDescription parseSyntaxChecker( String syntaxCheckerDescription ) throws ParseException
     {
         if ( ( syntaxCheckerDescription == null ) || Strings.isEmpty( syntaxCheckerDescription.trim() ) )
         {
             throw new ParseException( I18n.err( I18n.ERR_13716_NULL_OR_EMPTY_STRING_SCHEMA_OBJECT ), 0 );
         }
         
         try ( Reader reader = new BufferedReader( new StringReader( syntaxCheckerDescription ) ) )
         {
             PosSchema pos = new PosSchema();
 
             if ( isQuirksModeEnabled )
             {
                 return parseSyntaxCheckerRelaxed( reader, pos, objectIdentifierMacros );
             }
             else
             {
                 return parseSyntaxCheckerStrict( reader, pos, objectIdentifierMacros );
             }
         }
         catch ( IOException | LdapSchemaException e )
         {
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
     
     /**
      * Production for SyntaxChecker descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * SyntaxCheckerDescription = LPAREN WSP
      *       numericoid                           ; object identifier
      *       [ SP "DESC" SP qdstring ]            ; description
      *       SP "FQCN" SP fqcn                    ; fully qualified class name
      *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
      *       extensions WSP RPAREN                ; extensions
      * 
      * base64          = *(4base64-char)
      * base64-char     = ALPHA / DIGIT / "+" / "/"
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of SyntaxCheckerDescription
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static SyntaxCheckerDescription parseSyntaxCheckerStrict( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         // Check that the OID is valid
         if ( !Oid.isOid( oid ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13787_OID_EXPECTED, pos.lineNumber, pos.start ) );
         }
         
         SyntaxCheckerDescription syntaxChecker = new SyntaxCheckerDescription( oid );
         int elementsSeen = 0;
         boolean hasFqcn = false;
         boolean hasByteCode = false;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
 
             if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, SyntaxCheckerElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 syntaxChecker.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, FQCN_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, SyntaxCheckerElements.FQCN, pos );
 
                 pos.start += FQCN_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 String fqcn = getFqcn( pos );
                 syntaxChecker.setFqcn( fqcn );
                 hasFqcn = true;
             }
             else if ( startsWith( pos, BYTECODE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, SyntaxCheckerElements.BYTECODE, pos );
 
                 pos.start += BYTECODE_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 String byteCode = getByteCode( pos );
                 syntaxChecker.setBytecode( byteCode );
                 hasByteCode = true;
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, syntaxChecker );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13826_SC_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         // Semantic checks
         if ( !hasFqcn )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13819_FQCN_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         if ( ( hasByteCode ) && ( syntaxChecker.getBytecode().length() % 4 != 0 ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13820_BYTE_CODE_REQUIRED, 
                 pos.lineNumber, pos.start ) );
         }
 
         return syntaxChecker;
     }
 
     
     /**
      * Production for SyntaxChecker descriptions. It is fault-tolerant
      * against element ordering.
      *
      * <pre>
      * SyntaxCheckerDescription = LPAREN WSP
      *       numericoid                           ; object identifier
      *       [ SP "DESC" SP qdstring ]            ; description
      *       SP "FQCN" SP fqcn                    ; fully qualified class name
      *       [ SP "BYTECODE" SP base64 ]          ; optional base64 encoded bytecode
      *       extensions WSP RPAREN                ; extensions
      * 
      * base64          = *(4base64-char)
      * base64-char     = ALPHA / DIGIT / "+" / "/"
      * fqcn = fqcnComponent 1*( DOT fqcnComponent )
      * fqcnComponent = ???
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @param objectIdentifierMacros The set of existing Macros
      * @return An instance of SyntaxCheckerDescription
      * @throws LdapSchemaException If the schema is wrong
      * @throws IOException If the stream can't be read
      */
     private static SyntaxCheckerDescription parseSyntaxCheckerRelaxed( Reader reader, PosSchema pos,
         Map<String, OpenLdapObjectIdentifierMacro> objectIdentifierMacros ) 
             throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // we must have a '('
         if ( pos.line.charAt( pos.start ) != LPAREN )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13829_NO_OPENING_PAREN, 
                 pos.lineNumber, pos.start ) );
         }
         else
         {
             pos.start++;
         }
         
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the OID. 
         String oid = getOidAndMacroRelaxed( pos, objectIdentifierMacros );
         
         SyntaxCheckerDescription syntaxChecker = new SyntaxCheckerDescription( oid );
         int elementsSeen = 0;
         
         while ( true )
         {
             if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             
             skipWhites( reader, pos, true );
 
             if ( startsWith( pos, DESC_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, SyntaxCheckerElements.DESC, pos );
 
                 pos.start += DESC_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 syntaxChecker.setDescription( getQDString( reader, pos ) );
             }
             else if ( startsWith( pos, FQCN_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, SyntaxCheckerElements.FQCN, pos );
 
                 pos.start += FQCN_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 String fqcn = getFqcn( pos );
                 syntaxChecker.setFqcn( fqcn );
             }
             else if ( startsWith( pos, BYTECODE_STR ) )
             {
                 elementsSeen = checkElement( elementsSeen, SyntaxCheckerElements.BYTECODE, pos );
 
                 pos.start += BYTECODE_STR.length();
                 
                 skipWhites( reader, pos, true );
 
                 String byteCode = getByteCode( pos );
                 syntaxChecker.setBytecode( byteCode );
             }
             else if ( startsWith( pos, EXTENSION_PREFIX ) )
             {
                 processExtension( reader, pos, syntaxChecker );
             }
             else if ( startsWith( reader, pos, RPAREN ) )
             {
                 pos.start++;
                 break;
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13826_SC_DESCRIPTION_INVALID, 
                     pos.lineNumber, pos.start ) );
             }
         }
         
         return syntaxChecker;
     }
 
     
     /**
      * Process OpenLDAP macros, like : objectidentifier DUAConfSchemaOID 1.3.6.1.4.1.11.1.3.1.
      * 
      * <pre>
      * objectidentifier ::= 'objectidentifier' descr SP+ macroOid
      * descr             ::= ALPHA ( ALPHA | DIGIT | HYPHEN )*
      * macroOid         ::= (descr ':')? oid
      * </pre>
      * 
      * @param reader The stream reader
      * @param pos The position in the Schema
      * @throws LdapSchemaException If something went wrong in the schema
      * @throws IOException If the stream can't be read
      */
     private void processObjectIdentifier( Reader reader, PosSchema pos ) throws IOException, LdapSchemaException
     {
         // Get rid of whites, comments end empty lines
         skipWhites( reader, pos, false );
         
         // Now, the name
         String name = getDescrStrict( pos );
         
         OpenLdapObjectIdentifierMacro macro = new OpenLdapObjectIdentifierMacro();
         
         skipWhites( reader, pos, true );
 
         // Get the descr, if any
         if ( isEmpty( pos ) )
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13805_OBJECT_IDENTIFIER_INVALID_OID, 
                 pos.lineNumber, pos.start ) );
         }
         
         if ( isAlpha( pos ) )
         {
             // A macro
             String descr = getMacro( pos );
             
             if ( isEmpty( pos ) )
             {
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13804_OBJECT_IDENTIFIER_HAS_NO_OID, 
                     pos.lineNumber, pos.start ) );
             }
             
             if ( startsWith( reader, pos, COLON ) )
             {
                 pos.start++;
                 
                 // Now, the OID
                 String numericOid = getPartialNumericOid( pos );
                 String realOid = objectIdentifierMacros.get( descr ).getRawOidOrNameSuffix() + DOT + numericOid;
                 macro.setName( name );
                 macro.setRawOidOrNameSuffix( realOid );
                 
                 objectIdentifierMacros.put( name, macro );
             }
         }
         else if ( isDigit( pos ) )
         {
             // An oid
             String numericOid = getNumericOid( pos );
             macro.setRawOidOrNameSuffix( numericOid );
             macro.setName( name );
             
             objectIdentifierMacros.put( name, macro );
         }
         else
         {
             throw new LdapSchemaException( I18n.err( I18n.ERR_13805_OBJECT_IDENTIFIER_INVALID_OID, 
                 pos.lineNumber, pos.start ) );
         }
     }
     
     
     /**
      * Reads an entry in a ldif buffer, and returns the resulting lines, without
      * comments, and unfolded.
      *
      * The lines represent *one* entry.
      *
      * @param reader The stream reader
      * @throws LdapSchemaException If something went wrong in the schema
      * @throws IOException If the stream can't be read
      */
     public void parse( Reader reader ) throws LdapSchemaException, IOException
     {
         PosSchema pos = new PosSchema();
 
         while ( true )
         {
             // Always move forward to the next element, skipping whites, NL and comments
             skipWhites( reader, pos, false );
             
             if ( pos.line == null )
             {
                 // The end, get out
                 break;
             }
             
             // Ok, we have something which must be one of openLdapObjectIdentifier( "objectidentifier" ), 
             // openLdapAttributeType ( "attributetype" )  or openLdapObjectClass ( "objectclass" )
             if ( startsWith( pos, "objectidentifier" ) )
             {
                 pos.start += "objectidentifier".length();
                 
                 processObjectIdentifier( reader, pos );
             }
             else if ( startsWith( pos, "attributetype" ) )
             {
                 pos.start += "attributetype".length();
                 
                 AttributeType attributeType = parseAttributeTypeStrict( reader, pos, objectIdentifierMacros );
                 schemaDescriptions.add( attributeType );
             }
             else if ( startsWith( pos, "objectclass" ) )
             {
                 pos.start += "objectclass".length();
                 
                 ObjectClass objectClass = parseObjectClassStrict( reader, pos, objectIdentifierMacros );
                 schemaDescriptions.add( objectClass );
             }
             else
             {
                 // This is an error
                 throw new LdapSchemaException( I18n.err( I18n.ERR_13806_UNEXPECTED_ELEMENT_READ, 
                     pos.line.substring( pos.start ), pos.lineNumber, pos.start ) );
             }
         }
     }
 
 
     /**
      * Parses a file of OpenLDAP schemaObject elements/objects. Default charset is used.
      *
      * @param schemaFile a file of schema objects
      * @throws ParseException If the schemaObject can't be parsed
      */
     public void parse( File schemaFile ) throws ParseException
     {
         try ( InputStream is = Files.newInputStream( Paths.get( schemaFile.getPath() ) ) )
         {
             try ( Reader reader = new BufferedReader( new InputStreamReader( is, Charset.defaultCharset() ) ) )
             {
                 parse( reader );
                 afterParse();
             }
             catch ( LdapSchemaException | IOException e )
             {
                 throw new ParseException( e.getMessage(), 0 );
             }
         }
         catch ( IOException e )
         {
             String msg = I18n.err( I18n.ERR_13443_CANNOT_FIND_FILE, schemaFile.getAbsoluteFile() );
             LOG.error( msg );
             throw new ParseException( e.getMessage(), 0 );
         }
     }
 
 
     /**
      * Checks if object identifier macros should be resolved.
      * 
      * @return true, object identifier macros should be resolved.
      */
     public boolean isResolveObjectIdentifierMacros()
     {
         return isResolveObjectIdentifierMacros;
     }
 
 
     /**
      * Sets if object identifier macros should be resolved.
      * 
      * @param resolveObjectIdentifierMacros true if object identifier macros should be resolved
      */
     public void setResolveObjectIdentifierMacros( boolean resolveObjectIdentifierMacros )
     {
         this.isResolveObjectIdentifierMacros = resolveObjectIdentifierMacros;
     }
 
     /**
      * Checks if quirks mode is enabled.
      * 
      * @return true, if is quirks mode is enabled
      */
     public boolean isQuirksMode()
     {
         return isQuirksModeEnabled;
     }
 
 
     /**
      * Sets the quirks mode. 
      * 
      * If enabled the parser accepts non-numeric OIDs and some 
      * special characters in descriptions.
      * 
      * @param enabled the new quirks mode
      */
     public void setQuirksMode( boolean enabled )
     {
         isQuirksModeEnabled = enabled;
     }
 }